1 // Copyright 2016 The Chromium Authors
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/quic/bidirectional_stream_quic_impl.h"
6
7 #include <memory>
8 #include <utility>
9
10 #include "base/memory/ptr_util.h"
11 #include "base/memory/raw_ptr.h"
12 #include "base/run_loop.h"
13 #include "base/strings/strcat.h"
14 #include "base/strings/string_number_conversions.h"
15 #include "base/task/single_thread_task_runner.h"
16 #include "base/time/default_tick_clock.h"
17 #include "base/time/time.h"
18 #include "base/timer/timer.h"
19 #include "net/base/completion_once_callback.h"
20 #include "net/base/connection_endpoint_metadata.h"
21 #include "net/base/ip_address.h"
22 #include "net/base/load_timing_info.h"
23 #include "net/base/load_timing_info_test_util.h"
24 #include "net/base/net_errors.h"
25 #include "net/base/network_anonymization_key.h"
26 #include "net/base/privacy_mode.h"
27 #include "net/base/proxy_chain.h"
28 #include "net/base/session_usage.h"
29 #include "net/dns/public/host_resolver_results.h"
30 #include "net/dns/public/secure_dns_policy.h"
31 #include "net/http/bidirectional_stream_request_info.h"
32 #include "net/http/transport_security_state.h"
33 #include "net/log/net_log.h"
34 #include "net/log/net_log_event_type.h"
35 #include "net/log/test_net_log.h"
36 #include "net/log/test_net_log_util.h"
37 #include "net/quic/address_utils.h"
38 #include "net/quic/mock_crypto_client_stream_factory.h"
39 #include "net/quic/quic_chromium_alarm_factory.h"
40 #include "net/quic/quic_chromium_connection_helper.h"
41 #include "net/quic/quic_chromium_packet_reader.h"
42 #include "net/quic/quic_chromium_packet_writer.h"
43 #include "net/quic/quic_context.h"
44 #include "net/quic/quic_crypto_client_config_handle.h"
45 #include "net/quic/quic_http_utils.h"
46 #include "net/quic/quic_server_info.h"
47 #include "net/quic/quic_session_key.h"
48 #include "net/quic/quic_session_pool.h"
49 #include "net/quic/quic_test_packet_maker.h"
50 #include "net/quic/quic_test_packet_printer.h"
51 #include "net/quic/test_quic_crypto_client_config_handle.h"
52 #include "net/quic/test_task_runner.h"
53 #include "net/socket/socket_test_util.h"
54 #include "net/ssl/ssl_config_service_defaults.h"
55 #include "net/test/gtest_util.h"
56 #include "net/test/test_with_task_environment.h"
57 #include "net/third_party/quiche/src/quiche/common/quiche_text_utils.h"
58 #include "net/third_party/quiche/src/quiche/quic/core/crypto/crypto_protocol.h"
59 #include "net/third_party/quiche/src/quiche/quic/core/crypto/quic_decrypter.h"
60 #include "net/third_party/quiche/src/quiche/quic/core/crypto/quic_encrypter.h"
61 #include "net/third_party/quiche/src/quiche/quic/core/http/spdy_utils.h"
62 #include "net/third_party/quiche/src/quiche/quic/core/quic_connection.h"
63 #include "net/third_party/quiche/src/quiche/quic/test_tools/crypto_test_utils.h"
64 #include "net/third_party/quiche/src/quiche/quic/test_tools/mock_clock.h"
65 #include "net/third_party/quiche/src/quiche/quic/test_tools/mock_connection_id_generator.h"
66 #include "net/third_party/quiche/src/quiche/quic/test_tools/mock_random.h"
67 #include "net/third_party/quiche/src/quiche/quic/test_tools/qpack/qpack_test_utils.h"
68 #include "net/third_party/quiche/src/quiche/quic/test_tools/quic_connection_peer.h"
69 #include "net/third_party/quiche/src/quiche/quic/test_tools/quic_session_peer.h"
70 #include "net/third_party/quiche/src/quiche/quic/test_tools/quic_spdy_session_peer.h"
71 #include "net/third_party/quiche/src/quiche/quic/test_tools/quic_test_utils.h"
72 #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
73 #include "testing/gmock/include/gmock/gmock.h"
74 #include "testing/gtest/include/gtest/gtest.h"
75 #include "url/scheme_host_port.h"
76 #include "url/url_constants.h"
77
78 namespace net::test {
79
80 namespace {
81
82 const char kUploadData[] = "Really nifty data!";
83 const char kDefaultServerHostName[] = "www.google.com";
84 const uint16_t kDefaultServerPort = 80;
85 // Size of the buffer to be allocated for each read.
86 const size_t kReadBufferSize = 4096;
87
88 enum DelegateMethod {
89 kOnStreamReady,
90 kOnHeadersReceived,
91 kOnTrailersReceived,
92 kOnDataRead,
93 kOnDataSent,
94 kOnFailed
95 };
96
97 class TestDelegateBase : public BidirectionalStreamImpl::Delegate {
98 public:
TestDelegateBase(IOBuffer * read_buf,int read_buf_len)99 TestDelegateBase(IOBuffer* read_buf, int read_buf_len)
100 : TestDelegateBase(read_buf,
101 read_buf_len,
102 std::make_unique<base::OneShotTimer>()) {}
103
TestDelegateBase(IOBuffer * read_buf,int read_buf_len,std::unique_ptr<base::OneShotTimer> timer)104 TestDelegateBase(IOBuffer* read_buf,
105 int read_buf_len,
106 std::unique_ptr<base::OneShotTimer> timer)
107 : read_buf_(read_buf),
108 read_buf_len_(read_buf_len),
109 timer_(std::move(timer)) {
110 loop_ = std::make_unique<base::RunLoop>();
111 }
112
113 TestDelegateBase(const TestDelegateBase&) = delete;
114 TestDelegateBase& operator=(const TestDelegateBase&) = delete;
115
116 ~TestDelegateBase() override = default;
117
OnStreamReady(bool request_headers_sent)118 void OnStreamReady(bool request_headers_sent) override {
119 CHECK(!is_ready_);
120 CHECK(!on_failed_called_);
121 EXPECT_EQ(send_request_headers_automatically_, request_headers_sent);
122 CHECK(!not_expect_callback_);
123 is_ready_ = true;
124 loop_->Quit();
125 }
126
OnHeadersReceived(const spdy::Http2HeaderBlock & response_headers)127 void OnHeadersReceived(
128 const spdy::Http2HeaderBlock& response_headers) override {
129 CHECK(!on_failed_called_);
130 CHECK(!not_expect_callback_);
131
132 response_headers_ = response_headers.Clone();
133 loop_->Quit();
134 }
135
OnDataRead(int bytes_read)136 void OnDataRead(int bytes_read) override {
137 CHECK(!on_failed_called_);
138 CHECK(!not_expect_callback_);
139 CHECK(!callback_.is_null());
140
141 // If read EOF, make sure this callback is after trailers callback.
142 if (bytes_read == 0) {
143 EXPECT_TRUE(!trailers_expected_ || trailers_received_);
144 }
145 ++on_data_read_count_;
146 CHECK_GE(bytes_read, OK);
147 data_received_.append(read_buf_->data(), bytes_read);
148 std::move(callback_).Run(bytes_read);
149 }
150
OnDataSent()151 void OnDataSent() override {
152 CHECK(!on_failed_called_);
153 CHECK(!not_expect_callback_);
154
155 ++on_data_sent_count_;
156 loop_->Quit();
157 }
158
OnTrailersReceived(const spdy::Http2HeaderBlock & trailers)159 void OnTrailersReceived(const spdy::Http2HeaderBlock& trailers) override {
160 CHECK(!on_failed_called_);
161 CHECK(!not_expect_callback_);
162
163 trailers_received_ = true;
164 trailers_ = trailers.Clone();
165 loop_->Quit();
166 }
167
OnFailed(int error)168 void OnFailed(int error) override {
169 CHECK(!on_failed_called_);
170 CHECK(!not_expect_callback_);
171 CHECK_EQ(OK, error_);
172 CHECK_NE(OK, error);
173
174 on_failed_called_ = true;
175 error_ = error;
176 loop_->Quit();
177 }
178
Start(const BidirectionalStreamRequestInfo * request_info,const NetLogWithSource & net_log,std::unique_ptr<QuicChromiumClientSession::Handle> session)179 void Start(const BidirectionalStreamRequestInfo* request_info,
180 const NetLogWithSource& net_log,
181 std::unique_ptr<QuicChromiumClientSession::Handle> session) {
182 not_expect_callback_ = true;
183 stream_ = std::make_unique<BidirectionalStreamQuicImpl>(std::move(session));
184 stream_->Start(request_info, net_log, send_request_headers_automatically_,
185 this, nullptr, TRAFFIC_ANNOTATION_FOR_TESTS);
186 not_expect_callback_ = false;
187 }
188
SendRequestHeaders()189 void SendRequestHeaders() {
190 not_expect_callback_ = true;
191 stream_->SendRequestHeaders();
192 not_expect_callback_ = false;
193 }
194
SendData(const scoped_refptr<IOBuffer> & data,int length,bool end_of_stream)195 void SendData(const scoped_refptr<IOBuffer>& data,
196 int length,
197 bool end_of_stream) {
198 SendvData({data}, {length}, end_of_stream);
199 }
200
SendvData(const std::vector<scoped_refptr<IOBuffer>> & data,const std::vector<int> & lengths,bool end_of_stream)201 void SendvData(const std::vector<scoped_refptr<IOBuffer>>& data,
202 const std::vector<int>& lengths,
203 bool end_of_stream) {
204 not_expect_callback_ = true;
205 stream_->SendvData(data, lengths, end_of_stream);
206 not_expect_callback_ = false;
207 }
208
209 // Waits until next Delegate callback.
WaitUntilNextCallback(DelegateMethod method)210 void WaitUntilNextCallback(DelegateMethod method) {
211 ASSERT_FALSE(on_failed_called_);
212 bool is_ready = is_ready_;
213 bool headers_received = !response_headers_.empty();
214 bool trailers_received = trailers_received_;
215 int on_data_read_count = on_data_read_count_;
216 int on_data_sent_count = on_data_sent_count_;
217
218 loop_->Run();
219 loop_ = std::make_unique<base::RunLoop>();
220
221 EXPECT_EQ(method == kOnFailed, on_failed_called_);
222 EXPECT_EQ(is_ready || (method == kOnStreamReady), is_ready_);
223 EXPECT_EQ(headers_received || (method == kOnHeadersReceived),
224 !response_headers_.empty());
225 EXPECT_EQ(trailers_received || (method == kOnTrailersReceived),
226 trailers_received_);
227 EXPECT_EQ(on_data_read_count + (method == kOnDataRead ? 1 : 0),
228 on_data_read_count_);
229 EXPECT_EQ(on_data_sent_count + (method == kOnDataSent ? 1 : 0),
230 on_data_sent_count_);
231 }
232
233 // Calls ReadData on the |stream_| and updates |data_received_|.
ReadData(CompletionOnceCallback callback)234 int ReadData(CompletionOnceCallback callback) {
235 not_expect_callback_ = true;
236 int rv = stream_->ReadData(read_buf_.get(), read_buf_len_);
237 not_expect_callback_ = false;
238 if (rv > 0) {
239 data_received_.append(read_buf_->data(), rv);
240 }
241 if (rv == ERR_IO_PENDING) {
242 callback_ = std::move(callback);
243 }
244 return rv;
245 }
246
GetProtocol() const247 NextProto GetProtocol() const {
248 if (stream_) {
249 return stream_->GetProtocol();
250 }
251 return next_proto_;
252 }
253
GetTotalReceivedBytes() const254 int64_t GetTotalReceivedBytes() const {
255 if (stream_) {
256 return stream_->GetTotalReceivedBytes();
257 }
258 return received_bytes_;
259 }
260
GetTotalSentBytes() const261 int64_t GetTotalSentBytes() const {
262 if (stream_) {
263 return stream_->GetTotalSentBytes();
264 }
265 return sent_bytes_;
266 }
267
GetLoadTimingInfo(LoadTimingInfo * load_timing_info)268 bool GetLoadTimingInfo(LoadTimingInfo* load_timing_info) {
269 if (stream_) {
270 return stream_->GetLoadTimingInfo(load_timing_info);
271 }
272 *load_timing_info = load_timing_info_;
273 return has_load_timing_info_;
274 }
275
DoNotSendRequestHeadersAutomatically()276 void DoNotSendRequestHeadersAutomatically() {
277 send_request_headers_automatically_ = false;
278 }
279
280 // Deletes |stream_|.
DeleteStream()281 void DeleteStream() {
282 next_proto_ = stream_->GetProtocol();
283 received_bytes_ = stream_->GetTotalReceivedBytes();
284 sent_bytes_ = stream_->GetTotalSentBytes();
285 has_load_timing_info_ = stream_->GetLoadTimingInfo(&load_timing_info_);
286 stream_.reset();
287 }
288
set_trailers_expected(bool trailers_expected)289 void set_trailers_expected(bool trailers_expected) {
290 trailers_expected_ = trailers_expected;
291 }
292 // Const getters for internal states.
data_received() const293 const std::string& data_received() const { return data_received_; }
error() const294 int error() const { return error_; }
response_headers() const295 const spdy::Http2HeaderBlock& response_headers() const {
296 return response_headers_;
297 }
trailers() const298 const spdy::Http2HeaderBlock& trailers() const { return trailers_; }
on_data_read_count() const299 int on_data_read_count() const { return on_data_read_count_; }
on_data_sent_count() const300 int on_data_sent_count() const { return on_data_sent_count_; }
on_failed_called() const301 bool on_failed_called() const { return on_failed_called_; }
is_ready() const302 bool is_ready() const { return is_ready_; }
303
304 protected:
305 // Quits |loop_|.
QuitLoop()306 void QuitLoop() { loop_->Quit(); }
307
308 private:
309 std::unique_ptr<BidirectionalStreamQuicImpl> stream_;
310 scoped_refptr<IOBuffer> read_buf_;
311 int read_buf_len_;
312 std::unique_ptr<base::OneShotTimer> timer_;
313 std::string data_received_;
314 std::unique_ptr<base::RunLoop> loop_;
315 spdy::Http2HeaderBlock response_headers_;
316 spdy::Http2HeaderBlock trailers_;
317 NextProto next_proto_ = kProtoUnknown;
318 int64_t received_bytes_ = 0;
319 int64_t sent_bytes_ = 0;
320 bool has_load_timing_info_ = false;
321 LoadTimingInfo load_timing_info_;
322 int error_ = OK;
323 int on_data_read_count_ = 0;
324 int on_data_sent_count_ = 0;
325 // This is to ensure that delegate callback is not invoked synchronously when
326 // calling into |stream_|.
327 bool not_expect_callback_ = false;
328 bool on_failed_called_ = false;
329 CompletionOnceCallback callback_;
330 bool send_request_headers_automatically_ = true;
331 bool is_ready_ = false;
332 bool trailers_expected_ = false;
333 bool trailers_received_ = false;
334 };
335
336 // A delegate that deletes the stream in a particular callback.
337 class DeleteStreamDelegate : public TestDelegateBase {
338 public:
339 // Specifies in which callback the stream can be deleted.
340 enum Phase {
341 ON_STREAM_READY,
342 ON_HEADERS_RECEIVED,
343 ON_DATA_READ,
344 ON_TRAILERS_RECEIVED,
345 ON_FAILED,
346 };
347
DeleteStreamDelegate(IOBuffer * buf,int buf_len,Phase phase)348 DeleteStreamDelegate(IOBuffer* buf, int buf_len, Phase phase)
349 : TestDelegateBase(buf, buf_len), phase_(phase) {}
350
351 DeleteStreamDelegate(const DeleteStreamDelegate&) = delete;
352 DeleteStreamDelegate& operator=(const DeleteStreamDelegate&) = delete;
353
354 ~DeleteStreamDelegate() override = default;
355
OnStreamReady(bool request_headers_sent)356 void OnStreamReady(bool request_headers_sent) override {
357 TestDelegateBase::OnStreamReady(request_headers_sent);
358 if (phase_ == ON_STREAM_READY) {
359 DeleteStream();
360 }
361 }
362
OnHeadersReceived(const spdy::Http2HeaderBlock & response_headers)363 void OnHeadersReceived(
364 const spdy::Http2HeaderBlock& response_headers) override {
365 // Make a copy of |response_headers| before the stream is deleted, since
366 // the headers are owned by the stream.
367 spdy::Http2HeaderBlock headers_copy = response_headers.Clone();
368 if (phase_ == ON_HEADERS_RECEIVED) {
369 DeleteStream();
370 }
371 TestDelegateBase::OnHeadersReceived(headers_copy);
372 }
373
OnDataSent()374 void OnDataSent() override { NOTREACHED(); }
375
OnDataRead(int bytes_read)376 void OnDataRead(int bytes_read) override {
377 DCHECK_NE(ON_HEADERS_RECEIVED, phase_);
378 if (phase_ == ON_DATA_READ) {
379 DeleteStream();
380 }
381 TestDelegateBase::OnDataRead(bytes_read);
382 }
383
OnTrailersReceived(const spdy::Http2HeaderBlock & trailers)384 void OnTrailersReceived(const spdy::Http2HeaderBlock& trailers) override {
385 DCHECK_NE(ON_HEADERS_RECEIVED, phase_);
386 DCHECK_NE(ON_DATA_READ, phase_);
387 // Make a copy of |response_headers| before the stream is deleted, since
388 // the headers are owned by the stream.
389 spdy::Http2HeaderBlock trailers_copy = trailers.Clone();
390 if (phase_ == ON_TRAILERS_RECEIVED) {
391 DeleteStream();
392 }
393 TestDelegateBase::OnTrailersReceived(trailers_copy);
394 }
395
OnFailed(int error)396 void OnFailed(int error) override {
397 DCHECK_EQ(ON_FAILED, phase_);
398 DeleteStream();
399 TestDelegateBase::OnFailed(error);
400 }
401
402 private:
403 // Indicates in which callback the delegate should cancel or delete the
404 // stream.
405 Phase phase_;
406 };
407
408 } // namespace
409
410 class BidirectionalStreamQuicImplTest
411 : public ::testing::TestWithParam<quic::ParsedQuicVersion>,
412 public WithTaskEnvironment {
413 protected:
414 static const bool kFin = true;
415
416 // Holds a packet to be written to the wire, and the IO mode that should
417 // be used by the mock socket when performing the write.
418 struct PacketToWrite {
PacketToWritenet::test::BidirectionalStreamQuicImplTest::PacketToWrite419 PacketToWrite(IoMode mode, quic::QuicReceivedPacket* packet)
420 : mode(mode), packet(packet) {}
PacketToWritenet::test::BidirectionalStreamQuicImplTest::PacketToWrite421 PacketToWrite(IoMode mode, int rv) : mode(mode), packet(nullptr), rv(rv) {}
422 IoMode mode;
423 raw_ptr<quic::QuicReceivedPacket, DanglingUntriaged> packet;
424 int rv;
425 };
426
BidirectionalStreamQuicImplTest()427 BidirectionalStreamQuicImplTest()
428 : version_(GetParam()),
429 crypto_config_(
430 quic::test::crypto_test_utils::ProofVerifierForTesting()),
431 read_buffer_(base::MakeRefCounted<IOBufferWithSize>(4096)),
432 connection_id_(quic::test::TestConnectionId(2)),
433 stream_id_(GetNthClientInitiatedBidirectionalStreamId(0)),
434 client_maker_(version_,
435 connection_id_,
436 &clock_,
437 kDefaultServerHostName,
438 quic::Perspective::IS_CLIENT),
439 server_maker_(version_,
440 connection_id_,
441 &clock_,
442 kDefaultServerHostName,
443 quic::Perspective::IS_SERVER,
444 false),
445 printer_(version_),
446 destination_(url::kHttpsScheme,
447 kDefaultServerHostName,
448 kDefaultServerPort) {
449 quic::QuicEnableVersion(version_);
450 FLAGS_quic_enable_http3_grease_randomness = false;
451 IPAddress ip(192, 0, 2, 33);
452 peer_addr_ = IPEndPoint(ip, 443);
453 self_addr_ = IPEndPoint(ip, 8435);
454 clock_.AdvanceTime(quic::QuicTime::Delta::FromMilliseconds(20));
455 }
456
~BidirectionalStreamQuicImplTest()457 ~BidirectionalStreamQuicImplTest() override {
458 if (session_) {
459 session_->CloseSessionOnError(
460 ERR_ABORTED, quic::QUIC_INTERNAL_ERROR,
461 quic::ConnectionCloseBehavior::SILENT_CLOSE);
462 }
463 for (auto& write : writes_) {
464 delete write.packet;
465 }
466 }
467
TearDown()468 void TearDown() override {
469 if (socket_data_) {
470 EXPECT_TRUE(socket_data_->AllReadDataConsumed());
471 EXPECT_TRUE(socket_data_->AllWriteDataConsumed());
472 }
473 }
474
475 // Adds a packet to the list of expected writes.
AddWrite(std::unique_ptr<quic::QuicReceivedPacket> packet)476 void AddWrite(std::unique_ptr<quic::QuicReceivedPacket> packet) {
477 writes_.emplace_back(SYNCHRONOUS, packet.release());
478 }
479
480 // Adds a write error to the list of expected writes.
AddWriteError(IoMode mode,int rv)481 void AddWriteError(IoMode mode, int rv) { writes_.emplace_back(mode, rv); }
482
ProcessPacket(std::unique_ptr<quic::QuicReceivedPacket> packet)483 void ProcessPacket(std::unique_ptr<quic::QuicReceivedPacket> packet) {
484 connection_->ProcessUdpPacket(ToQuicSocketAddress(self_addr_),
485 ToQuicSocketAddress(peer_addr_), *packet);
486 }
487
488 // Configures the test fixture to use the list of expected writes.
Initialize()489 void Initialize() {
490 crypto_client_stream_factory_.set_handshake_mode(
491 MockCryptoClientStream::ZERO_RTT);
492 mock_writes_ = std::make_unique<MockWrite[]>(writes_.size());
493 for (size_t i = 0; i < writes_.size(); i++) {
494 if (writes_[i].packet == nullptr) {
495 mock_writes_[i] = MockWrite(writes_[i].mode, writes_[i].rv, i);
496 } else {
497 mock_writes_[i] = MockWrite(writes_[i].mode, writes_[i].packet->data(),
498 writes_[i].packet->length());
499 }
500 }
501
502 socket_data_ = std::make_unique<StaticSocketDataProvider>(
503 base::span<MockRead>(),
504 base::make_span(mock_writes_.get(), writes_.size()));
505 socket_data_->set_printer(&printer_);
506
507 auto socket = std::make_unique<MockUDPClientSocket>(socket_data_.get(),
508 NetLog::Get());
509 socket->Connect(peer_addr_);
510 runner_ = base::MakeRefCounted<TestTaskRunner>(&clock_);
511 helper_ = std::make_unique<QuicChromiumConnectionHelper>(
512 &clock_, &random_generator_);
513 alarm_factory_ =
514 std::make_unique<QuicChromiumAlarmFactory>(runner_.get(), &clock_);
515 connection_ = new quic::QuicConnection(
516 connection_id_, quic::QuicSocketAddress(),
517 ToQuicSocketAddress(peer_addr_), helper_.get(), alarm_factory_.get(),
518 new QuicChromiumPacketWriter(socket.get(), runner_.get()),
519 true /* owns_writer */, quic::Perspective::IS_CLIENT,
520 quic::test::SupportedVersions(version_), connection_id_generator_);
521 if (connection_->version().KnowsWhichDecrypterToUse()) {
522 connection_->InstallDecrypter(
523 quic::ENCRYPTION_FORWARD_SECURE,
524 std::make_unique<quic::test::StrictTaggingDecrypter>(
525 quic::ENCRYPTION_FORWARD_SECURE));
526 }
527 base::TimeTicks dns_end = base::TimeTicks::Now();
528 base::TimeTicks dns_start = dns_end - base::Milliseconds(1);
529
530 session_ = std::make_unique<QuicChromiumClientSession>(
531 connection_, std::move(socket),
532 /*stream_factory=*/nullptr, &crypto_client_stream_factory_, &clock_,
533 &transport_security_state_, &ssl_config_service_,
534 base::WrapUnique(static_cast<QuicServerInfo*>(nullptr)),
535 QuicSessionKey(kDefaultServerHostName, kDefaultServerPort,
536 PRIVACY_MODE_DISABLED, ProxyChain::Direct(),
537 SessionUsage::kDestination, SocketTag(),
538 NetworkAnonymizationKey(), SecureDnsPolicy::kAllow,
539 /*require_dns_https_alpn=*/false),
540 /*require_confirmation=*/false,
541 /*migrate_session_early_v2=*/false,
542 /*migrate_session_on_network_change_v2=*/false,
543 /*default_network=*/handles::kInvalidNetworkHandle,
544 quic::QuicTime::Delta::FromMilliseconds(
545 kDefaultRetransmittableOnWireTimeout.InMilliseconds()),
546 /*migrate_idle_session=*/false, /*allow_port_migration=*/false,
547 kDefaultIdleSessionMigrationPeriod, /*multi_port_probing_interval=*/0,
548 kMaxTimeOnNonDefaultNetwork,
549 kMaxMigrationsToNonDefaultNetworkOnWriteError,
550 kMaxMigrationsToNonDefaultNetworkOnPathDegrading,
551 kQuicYieldAfterPacketsRead,
552 quic::QuicTime::Delta::FromMilliseconds(
553 kQuicYieldAfterDurationMilliseconds),
554 /*cert_verify_flags=*/0, quic::test::DefaultQuicConfig(),
555 std::make_unique<TestQuicCryptoClientConfigHandle>(&crypto_config_),
556 "CONNECTION_UNKNOWN", dns_start, dns_end,
557 base::DefaultTickClock::GetInstance(),
558 base::SingleThreadTaskRunner::GetCurrentDefault().get(),
559 /*socket_performance_watcher=*/nullptr, ConnectionEndpointMetadata(),
560 NetLogWithSource::Make(NetLogSourceType::NONE));
561 session_->Initialize();
562
563 // Blackhole QPACK decoder stream instead of constructing mock writes.
564 session_->qpack_decoder()->set_qpack_stream_sender_delegate(
565 &noop_qpack_stream_sender_delegate_);
566
567 TestCompletionCallback callback;
568 session_->CryptoConnect(callback.callback());
569 EXPECT_TRUE(session_->IsEncryptionEstablished());
570 }
571
ConfirmHandshake()572 void ConfirmHandshake() {
573 crypto_client_stream_factory_.last_stream()
574 ->NotifySessionOneRttKeyAvailable();
575 }
576
SetRequest(const std::string & method,const std::string & path,RequestPriority priority)577 void SetRequest(const std::string& method,
578 const std::string& path,
579 RequestPriority priority) {
580 request_headers_ = client_maker_.GetRequestHeaders(method, "http", path);
581 }
582
ConstructResponseHeaders(const std::string & response_code)583 spdy::Http2HeaderBlock ConstructResponseHeaders(
584 const std::string& response_code) {
585 return server_maker_.GetResponseHeaders(response_code);
586 }
587
ConstructServerDataPacket(uint64_t packet_number,bool fin,std::string_view data)588 std::unique_ptr<quic::QuicReceivedPacket> ConstructServerDataPacket(
589 uint64_t packet_number,
590 bool fin,
591 std::string_view data) {
592 std::unique_ptr<quic::QuicReceivedPacket> packet(
593 server_maker_.MakeDataPacket(packet_number, stream_id_, fin, data));
594 DVLOG(2) << "packet(" << packet_number << "): " << std::endl
595 << quiche::QuicheTextUtils::HexDump(packet->AsStringPiece());
596 return packet;
597 }
598
ConstructClientDataPacket(bool fin,std::string_view data)599 std::unique_ptr<quic::QuicReceivedPacket> ConstructClientDataPacket(
600 bool fin,
601 std::string_view data) {
602 return client_maker_.MakeDataPacket(++packet_number_, stream_id_, fin,
603 data);
604 }
605
ConstructRequestHeadersPacket(bool fin,RequestPriority request_priority,size_t * spdy_headers_frame_length)606 std::unique_ptr<quic::QuicReceivedPacket> ConstructRequestHeadersPacket(
607 bool fin,
608 RequestPriority request_priority,
609 size_t* spdy_headers_frame_length) {
610 return ConstructRequestHeadersPacketInner(stream_id_, fin, request_priority,
611 spdy_headers_frame_length);
612 }
613
ConstructRequestHeadersPacketInner(quic::QuicStreamId stream_id,bool fin,RequestPriority request_priority,size_t * spdy_headers_frame_length)614 std::unique_ptr<quic::QuicReceivedPacket> ConstructRequestHeadersPacketInner(
615 quic::QuicStreamId stream_id,
616 bool fin,
617 RequestPriority request_priority,
618 size_t* spdy_headers_frame_length) {
619 spdy::SpdyPriority priority =
620 ConvertRequestPriorityToQuicPriority(request_priority);
621 std::unique_ptr<quic::QuicReceivedPacket> packet(
622 client_maker_.MakeRequestHeadersPacket(
623 ++packet_number_, stream_id, fin, priority,
624 std::move(request_headers_), spdy_headers_frame_length));
625 DVLOG(2) << "packet(" << packet_number_ << "): " << std::endl
626 << quiche::QuicheTextUtils::HexDump(packet->AsStringPiece());
627 return packet;
628 }
629
630 std::unique_ptr<quic::QuicReceivedPacket>
ConstructRequestHeadersAndMultipleDataFramesPacket(bool fin,RequestPriority request_priority,size_t * spdy_headers_frame_length,const std::vector<std::string> & data)631 ConstructRequestHeadersAndMultipleDataFramesPacket(
632 bool fin,
633 RequestPriority request_priority,
634 size_t* spdy_headers_frame_length,
635 const std::vector<std::string>& data) {
636 spdy::SpdyPriority priority =
637 ConvertRequestPriorityToQuicPriority(request_priority);
638 std::unique_ptr<quic::QuicReceivedPacket> packet(
639 client_maker_.MakeRequestHeadersAndMultipleDataFramesPacket(
640 ++packet_number_, stream_id_, fin, priority,
641 std::move(request_headers_), spdy_headers_frame_length, data));
642 DVLOG(2) << "packet(" << packet_number_ << "): " << std::endl
643 << quiche::QuicheTextUtils::HexDump(packet->AsStringPiece());
644 return packet;
645 }
646
ConstructResponseHeadersPacket(uint64_t packet_number,bool fin,spdy::Http2HeaderBlock response_headers,size_t * spdy_headers_frame_length)647 std::unique_ptr<quic::QuicReceivedPacket> ConstructResponseHeadersPacket(
648 uint64_t packet_number,
649 bool fin,
650 spdy::Http2HeaderBlock response_headers,
651 size_t* spdy_headers_frame_length) {
652 return ConstructResponseHeadersPacketInner(packet_number, stream_id_, fin,
653 std::move(response_headers),
654 spdy_headers_frame_length);
655 }
656
ConstructResponseHeadersPacketInner(uint64_t packet_number,quic::QuicStreamId stream_id,bool fin,spdy::Http2HeaderBlock response_headers,size_t * spdy_headers_frame_length)657 std::unique_ptr<quic::QuicReceivedPacket> ConstructResponseHeadersPacketInner(
658 uint64_t packet_number,
659 quic::QuicStreamId stream_id,
660 bool fin,
661 spdy::Http2HeaderBlock response_headers,
662 size_t* spdy_headers_frame_length) {
663 return server_maker_.MakeResponseHeadersPacket(
664 packet_number, stream_id, fin, std::move(response_headers),
665 spdy_headers_frame_length);
666 }
667
ConstructResponseTrailersPacket(uint64_t packet_number,bool fin,spdy::Http2HeaderBlock trailers,size_t * spdy_headers_frame_length)668 std::unique_ptr<quic::QuicReceivedPacket> ConstructResponseTrailersPacket(
669 uint64_t packet_number,
670 bool fin,
671 spdy::Http2HeaderBlock trailers,
672 size_t* spdy_headers_frame_length) {
673 return server_maker_.MakeResponseHeadersPacket(packet_number, stream_id_,
674 fin, std::move(trailers),
675 spdy_headers_frame_length);
676 }
677
ConstructClientRstStreamPacket()678 std::unique_ptr<quic::QuicReceivedPacket> ConstructClientRstStreamPacket() {
679 return ConstructRstStreamCancelledPacket(++packet_number_, &client_maker_);
680 }
681
ConstructServerRstStreamPacket(uint64_t packet_number)682 std::unique_ptr<quic::QuicReceivedPacket> ConstructServerRstStreamPacket(
683 uint64_t packet_number) {
684 return ConstructRstStreamCancelledPacket(packet_number, &server_maker_);
685 }
686
687 std::unique_ptr<quic::QuicReceivedPacket>
ConstructClientEarlyRstStreamPacket()688 ConstructClientEarlyRstStreamPacket() {
689 return ConstructRstStreamCancelledPacket(++packet_number_, &client_maker_);
690 }
691
ConstructRstStreamCancelledPacket(uint64_t packet_number,QuicTestPacketMaker * maker)692 std::unique_ptr<quic::QuicReceivedPacket> ConstructRstStreamCancelledPacket(
693 uint64_t packet_number,
694 QuicTestPacketMaker* maker) {
695 std::unique_ptr<quic::QuicReceivedPacket> packet(maker->MakeRstPacket(
696 packet_number, stream_id_, quic::QUIC_STREAM_CANCELLED,
697 /*include_stop_sending_if_v99=*/true));
698 DVLOG(2) << "packet(" << packet_number << "): " << std::endl
699 << quiche::QuicheTextUtils::HexDump(packet->AsStringPiece());
700 return packet;
701 }
702
703 std::unique_ptr<quic::QuicReceivedPacket>
ConstructClientAckAndRstStreamPacket(uint64_t largest_received,uint64_t smallest_received)704 ConstructClientAckAndRstStreamPacket(uint64_t largest_received,
705 uint64_t smallest_received) {
706 return client_maker_.MakeAckAndRstPacket(
707 ++packet_number_, stream_id_, quic::QUIC_STREAM_CANCELLED,
708 largest_received, smallest_received);
709 }
710
ConstructAckAndDataPacket(uint64_t packet_number,uint64_t largest_received,uint64_t smallest_received,bool fin,std::string_view data,QuicTestPacketMaker * maker)711 std::unique_ptr<quic::QuicReceivedPacket> ConstructAckAndDataPacket(
712 uint64_t packet_number,
713 uint64_t largest_received,
714 uint64_t smallest_received,
715 bool fin,
716 std::string_view data,
717 QuicTestPacketMaker* maker) {
718 std::unique_ptr<quic::QuicReceivedPacket> packet(
719 maker->MakeAckAndDataPacket(packet_number, stream_id_, largest_received,
720 smallest_received, fin, data));
721 DVLOG(2) << "packet(" << packet_number << "): " << std::endl
722 << quiche::QuicheTextUtils::HexDump(packet->AsStringPiece());
723 return packet;
724 }
725
ConstructClientAckPacket(uint64_t largest_received,uint64_t smallest_received)726 std::unique_ptr<quic::QuicReceivedPacket> ConstructClientAckPacket(
727 uint64_t largest_received,
728 uint64_t smallest_received) {
729 return client_maker_.MakeAckPacket(++packet_number_, largest_received,
730 smallest_received);
731 }
732
ConstructServerAckPacket(uint64_t packet_number,uint64_t largest_received,uint64_t smallest_received,uint64_t least_unacked)733 std::unique_ptr<quic::QuicReceivedPacket> ConstructServerAckPacket(
734 uint64_t packet_number,
735 uint64_t largest_received,
736 uint64_t smallest_received,
737 uint64_t least_unacked) {
738 return server_maker_.MakeAckPacket(packet_number, largest_received,
739 smallest_received, least_unacked);
740 }
741
ConstructInitialSettingsPacket()742 std::unique_ptr<quic::QuicReceivedPacket> ConstructInitialSettingsPacket() {
743 return client_maker_.MakeInitialSettingsPacket(++packet_number_);
744 }
745
ExpectLoadTimingValid(const LoadTimingInfo & load_timing_info,bool session_reused)746 void ExpectLoadTimingValid(const LoadTimingInfo& load_timing_info,
747 bool session_reused) {
748 EXPECT_EQ(session_reused, load_timing_info.socket_reused);
749
750 if (session_reused) {
751 ExpectConnectTimingHasNoTimes(load_timing_info.connect_timing);
752 } else {
753 ExpectConnectTimingHasTimes(
754 load_timing_info.connect_timing,
755 CONNECT_TIMING_HAS_SSL_TIMES | CONNECT_TIMING_HAS_DNS_TIMES);
756 }
757 ExpectLoadTimingHasOnlyConnectionTimes(load_timing_info);
758 }
759
net_log_observer() const760 const RecordingNetLogObserver& net_log_observer() const {
761 return net_log_observer_;
762 }
763
net_log_with_source() const764 const NetLogWithSource& net_log_with_source() const {
765 return net_log_with_source_;
766 }
767
session() const768 QuicChromiumClientSession* session() const { return session_.get(); }
769
GetNthClientInitiatedBidirectionalStreamId(int n)770 quic::QuicStreamId GetNthClientInitiatedBidirectionalStreamId(int n) {
771 return quic::test::GetNthClientInitiatedBidirectionalStreamId(
772 version_.transport_version, n);
773 }
774
ConstructDataHeader(size_t body_len)775 std::string ConstructDataHeader(size_t body_len) {
776 quiche::QuicheBuffer buffer = quic::HttpEncoder::SerializeDataFrameHeader(
777 body_len, quiche::SimpleBufferAllocator::Get());
778 return std::string(buffer.data(), buffer.size());
779 }
780
781 protected:
782 quic::test::QuicFlagSaver saver_;
783 const quic::ParsedQuicVersion version_;
784 RecordingNetLogObserver net_log_observer_;
785 NetLogWithSource net_log_with_source_{
786 NetLogWithSource::Make(NetLogSourceType::NONE)};
787 scoped_refptr<TestTaskRunner> runner_;
788 std::unique_ptr<MockWrite[]> mock_writes_;
789 quic::MockClock clock_;
790 raw_ptr<quic::QuicConnection, DanglingUntriaged> connection_;
791 std::unique_ptr<QuicChromiumConnectionHelper> helper_;
792 std::unique_ptr<QuicChromiumAlarmFactory> alarm_factory_;
793 TransportSecurityState transport_security_state_;
794 SSLConfigServiceDefaults ssl_config_service_;
795 std::unique_ptr<QuicChromiumClientSession> session_;
796 quic::QuicCryptoClientConfig crypto_config_;
797 HttpRequestHeaders headers_;
798 HttpResponseInfo response_;
799 scoped_refptr<IOBufferWithSize> read_buffer_;
800 spdy::Http2HeaderBlock request_headers_;
801 const quic::QuicConnectionId connection_id_;
802 const quic::QuicStreamId stream_id_;
803 QuicTestPacketMaker client_maker_;
804 uint64_t packet_number_ = 0;
805 QuicTestPacketMaker server_maker_;
806 IPEndPoint self_addr_;
807 IPEndPoint peer_addr_;
808 quic::test::MockRandom random_generator_{0};
809 QuicPacketPrinter printer_;
810 MockCryptoClientStreamFactory crypto_client_stream_factory_;
811 std::unique_ptr<StaticSocketDataProvider> socket_data_;
812 std::vector<PacketToWrite> writes_;
813 url::SchemeHostPort destination_;
814 quic::test::MockConnectionIdGenerator connection_id_generator_;
815 quic::test::NoopQpackStreamSenderDelegate noop_qpack_stream_sender_delegate_;
816 };
817
818 INSTANTIATE_TEST_SUITE_P(Version,
819 BidirectionalStreamQuicImplTest,
820 ::testing::ValuesIn(AllSupportedQuicVersions()),
821 ::testing::PrintToStringParamName());
822
TEST_P(BidirectionalStreamQuicImplTest,GetRequest)823 TEST_P(BidirectionalStreamQuicImplTest, GetRequest) {
824 SetRequest("GET", "/", DEFAULT_PRIORITY);
825 size_t spdy_request_headers_frame_length;
826 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
827 AddWrite(ConstructInitialSettingsPacket());
828 AddWrite(ConstructRequestHeadersPacketInner(
829 GetNthClientInitiatedBidirectionalStreamId(0), kFin, DEFAULT_PRIORITY,
830 &spdy_request_headers_frame_length));
831 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE);
832 AddWrite(ConstructClientAckPacket(3, 1));
833
834 Initialize();
835
836 BidirectionalStreamRequestInfo request;
837 request.method = "GET";
838 request.url = GURL("http://www.google.com/");
839 request.end_stream_on_headers = true;
840 request.priority = DEFAULT_PRIORITY;
841
842 auto read_buffer = base::MakeRefCounted<IOBufferWithSize>(kReadBufferSize);
843 auto delegate =
844 std::make_unique<TestDelegateBase>(read_buffer.get(), kReadBufferSize);
845 delegate->set_trailers_expected(true);
846 delegate->Start(&request, net_log_with_source(),
847 session()->CreateHandle(destination_));
848 delegate->WaitUntilNextCallback(kOnStreamReady);
849 ConfirmHandshake();
850
851 // Server acks the request.
852 ProcessPacket(ConstructServerAckPacket(1, 1, 1, 1));
853
854 // Server sends the response headers.
855 spdy::Http2HeaderBlock response_headers = ConstructResponseHeaders("200");
856
857 size_t spdy_response_headers_frame_length;
858 ProcessPacket(
859 ConstructResponseHeadersPacket(2, !kFin, std::move(response_headers),
860 &spdy_response_headers_frame_length));
861
862 delegate->WaitUntilNextCallback(kOnHeadersReceived);
863 LoadTimingInfo load_timing_info;
864 EXPECT_TRUE(delegate->GetLoadTimingInfo(&load_timing_info));
865 ExpectLoadTimingValid(load_timing_info, /*session_reused=*/false);
866 TestCompletionCallback cb;
867 int rv = delegate->ReadData(cb.callback());
868 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
869 EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
870 const char kResponseBody[] = "Hello world!";
871 // Server sends data.
872 std::string header = ConstructDataHeader(strlen(kResponseBody));
873 ProcessPacket(ConstructServerDataPacket(3, !kFin, header + kResponseBody));
874 EXPECT_EQ(12, cb.WaitForResult());
875
876 EXPECT_EQ(std::string(kResponseBody), delegate->data_received());
877 TestCompletionCallback cb2;
878 EXPECT_THAT(delegate->ReadData(cb2.callback()), IsError(ERR_IO_PENDING));
879
880 spdy::Http2HeaderBlock trailers;
881 size_t spdy_trailers_frame_length;
882 trailers["foo"] = "bar";
883 // Server sends trailers.
884 ProcessPacket(ConstructResponseTrailersPacket(4, kFin, trailers.Clone(),
885 &spdy_trailers_frame_length));
886
887 delegate->WaitUntilNextCallback(kOnTrailersReceived);
888 EXPECT_THAT(cb2.WaitForResult(), IsOk());
889 EXPECT_EQ(trailers, delegate->trailers());
890
891 EXPECT_THAT(delegate->ReadData(cb2.callback()), IsOk());
892 base::RunLoop().RunUntilIdle();
893
894 EXPECT_EQ(2, delegate->on_data_read_count());
895 EXPECT_EQ(0, delegate->on_data_sent_count());
896 EXPECT_EQ(kProtoQUIC, delegate->GetProtocol());
897 EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length),
898 delegate->GetTotalSentBytes());
899 EXPECT_EQ(static_cast<int64_t>(spdy_response_headers_frame_length +
900 strlen(kResponseBody) + header.length() +
901 spdy_trailers_frame_length),
902 delegate->GetTotalReceivedBytes());
903 // Check that NetLog was filled as expected.
904 auto entries = net_log_observer().GetEntries();
905 size_t pos = ExpectLogContainsSomewhere(
906 entries, /*min_offset=*/0,
907 NetLogEventType::QUIC_CHROMIUM_CLIENT_STREAM_SEND_REQUEST_HEADERS,
908 NetLogEventPhase::NONE);
909 pos = ExpectLogContainsSomewhere(
910 entries, /*min_offset=*/pos,
911 NetLogEventType::QUIC_CHROMIUM_CLIENT_STREAM_SEND_REQUEST_HEADERS,
912 NetLogEventPhase::NONE);
913 ExpectLogContainsSomewhere(
914 entries, /*min_offset=*/pos,
915 NetLogEventType::QUIC_CHROMIUM_CLIENT_STREAM_SEND_REQUEST_HEADERS,
916 NetLogEventPhase::NONE);
917 }
918
TEST_P(BidirectionalStreamQuicImplTest,LoadTimingTwoRequests)919 TEST_P(BidirectionalStreamQuicImplTest, LoadTimingTwoRequests) {
920 SetRequest("GET", "/", DEFAULT_PRIORITY);
921 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
922 AddWrite(ConstructInitialSettingsPacket());
923 AddWrite(ConstructRequestHeadersPacketInner(
924 GetNthClientInitiatedBidirectionalStreamId(0), kFin, DEFAULT_PRIORITY,
925 nullptr));
926 // SetRequest() again for second request as |request_headers_| was moved.
927 SetRequest("GET", "/", DEFAULT_PRIORITY);
928 AddWrite(ConstructRequestHeadersPacketInner(
929 GetNthClientInitiatedBidirectionalStreamId(1), kFin, DEFAULT_PRIORITY,
930 nullptr));
931 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE);
932 AddWrite(ConstructClientAckPacket(3, 1));
933 Initialize();
934
935 BidirectionalStreamRequestInfo request;
936 request.method = "GET";
937 request.url = GURL("http://www.google.com/");
938 request.end_stream_on_headers = true;
939 request.priority = DEFAULT_PRIORITY;
940
941 // Start first request.
942 auto read_buffer = base::MakeRefCounted<IOBufferWithSize>(kReadBufferSize);
943 auto delegate =
944 std::make_unique<TestDelegateBase>(read_buffer.get(), kReadBufferSize);
945 delegate->Start(&request, net_log_with_source(),
946 session()->CreateHandle(destination_));
947
948 // Start second request.
949 auto read_buffer2 = base::MakeRefCounted<IOBufferWithSize>(kReadBufferSize);
950 auto delegate2 =
951 std::make_unique<TestDelegateBase>(read_buffer2.get(), kReadBufferSize);
952 delegate2->Start(&request, net_log_with_source(),
953 session()->CreateHandle(destination_));
954
955 delegate->WaitUntilNextCallback(kOnStreamReady);
956 delegate2->WaitUntilNextCallback(kOnStreamReady);
957
958 ConfirmHandshake();
959 // Server acks the request.
960 ProcessPacket(ConstructServerAckPacket(1, 1, 1, 1));
961
962 // Server sends the response headers.
963 ProcessPacket(ConstructResponseHeadersPacketInner(
964 2, GetNthClientInitiatedBidirectionalStreamId(0), kFin,
965 ConstructResponseHeaders("200"), nullptr));
966
967 ProcessPacket(ConstructResponseHeadersPacketInner(
968 3, GetNthClientInitiatedBidirectionalStreamId(1), kFin,
969 ConstructResponseHeaders("200"), nullptr));
970
971 delegate->WaitUntilNextCallback(kOnHeadersReceived);
972 delegate2->WaitUntilNextCallback(kOnHeadersReceived);
973
974 LoadTimingInfo load_timing_info;
975 EXPECT_TRUE(delegate->GetLoadTimingInfo(&load_timing_info));
976 LoadTimingInfo load_timing_info2;
977 EXPECT_TRUE(delegate2->GetLoadTimingInfo(&load_timing_info2));
978 ExpectLoadTimingValid(load_timing_info, /*session_reused=*/false);
979 ExpectLoadTimingValid(load_timing_info2, /*session_reused=*/true);
980 EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
981 EXPECT_EQ("200", delegate2->response_headers().find(":status")->second);
982 // No response body. ReadData() should return OK synchronously.
983 TestCompletionCallback dummy_callback;
984 EXPECT_EQ(OK, delegate->ReadData(dummy_callback.callback()));
985 EXPECT_EQ(OK, delegate2->ReadData(dummy_callback.callback()));
986 }
987
988 // Tests that when request headers are not delayed, only data buffers are
989 // coalesced.
TEST_P(BidirectionalStreamQuicImplTest,CoalesceDataBuffersNotHeadersFrame)990 TEST_P(BidirectionalStreamQuicImplTest, CoalesceDataBuffersNotHeadersFrame) {
991 SetRequest("POST", "/", DEFAULT_PRIORITY);
992 size_t spdy_request_headers_frame_length;
993 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
994 AddWrite(ConstructInitialSettingsPacket());
995 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE);
996 const std::string kBody1 = "here are some data";
997 const std::string kBody2 = "data keep coming";
998 std::string header = ConstructDataHeader(kBody1.length());
999 std::string header2 = ConstructDataHeader(kBody2.length());
1000 std::vector<std::string> two_writes = {kBody1, kBody2};
1001 AddWrite(ConstructRequestHeadersPacketInner(
1002 GetNthClientInitiatedBidirectionalStreamId(0), !kFin, DEFAULT_PRIORITY,
1003 &spdy_request_headers_frame_length));
1004 AddWrite(
1005 ConstructClientDataPacket(!kFin, header + kBody1 + header2 + kBody2));
1006
1007 // Ack server's data packet.
1008 AddWrite(ConstructClientAckPacket(3, 1));
1009 const std::string kBody3 = "hello there";
1010 const std::string kBody4 = "another piece of small data";
1011 const std::string kBody5 = "really small";
1012 std::string header3 = ConstructDataHeader(kBody3.length());
1013 std::string header4 = ConstructDataHeader(kBody4.length());
1014 std::string header5 = ConstructDataHeader(kBody5.length());
1015 AddWrite(ConstructClientDataPacket(
1016 kFin, header3 + kBody3 + header4 + kBody4 + header5 + kBody5));
1017
1018 Initialize();
1019
1020 BidirectionalStreamRequestInfo request;
1021 request.method = "POST";
1022 request.url = GURL("http://www.google.com/");
1023 request.end_stream_on_headers = false;
1024 request.priority = DEFAULT_PRIORITY;
1025
1026 auto read_buffer = base::MakeRefCounted<IOBufferWithSize>(kReadBufferSize);
1027 auto delegate =
1028 std::make_unique<TestDelegateBase>(read_buffer.get(), kReadBufferSize);
1029 delegate->DoNotSendRequestHeadersAutomatically();
1030 delegate->Start(&request, net_log_with_source(),
1031 session()->CreateHandle(destination_));
1032 EXPECT_FALSE(delegate->is_ready());
1033 ConfirmHandshake();
1034 delegate->WaitUntilNextCallback(kOnStreamReady);
1035 EXPECT_TRUE(delegate->is_ready());
1036
1037 // Sends request headers separately, which causes them to be sent in a
1038 // separate packet.
1039 delegate->SendRequestHeaders();
1040 // Send a Data packet.
1041 scoped_refptr<StringIOBuffer> buf1 =
1042 base::MakeRefCounted<StringIOBuffer>(kBody1);
1043 scoped_refptr<StringIOBuffer> buf2 =
1044 base::MakeRefCounted<StringIOBuffer>(kBody2);
1045
1046 std::vector<int> lengths = {buf1->size(), buf2->size()};
1047 delegate->SendvData({buf1, buf2}, lengths, !kFin);
1048 delegate->WaitUntilNextCallback(kOnDataSent);
1049
1050 // Server acks the request.
1051 ProcessPacket(ConstructServerAckPacket(1, 1, 1, 1));
1052
1053 // Server sends the response headers.
1054 spdy::Http2HeaderBlock response_headers = ConstructResponseHeaders("200");
1055 size_t spdy_response_headers_frame_length;
1056 ProcessPacket(
1057 ConstructResponseHeadersPacket(2, !kFin, std::move(response_headers),
1058 &spdy_response_headers_frame_length));
1059
1060 delegate->WaitUntilNextCallback(kOnHeadersReceived);
1061 TestCompletionCallback cb;
1062 int rv = delegate->ReadData(cb.callback());
1063 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1064 EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
1065 const char kResponseBody[] = "Hello world!";
1066 std::string header6 = ConstructDataHeader(strlen(kResponseBody));
1067 // Server sends data.
1068 ProcessPacket(ConstructServerDataPacket(3, !kFin, header6 + kResponseBody));
1069
1070 EXPECT_EQ(static_cast<int>(strlen(kResponseBody)), cb.WaitForResult());
1071
1072 // Send a second Data packet.
1073 scoped_refptr<StringIOBuffer> buf3 =
1074 base::MakeRefCounted<StringIOBuffer>(kBody3);
1075 scoped_refptr<StringIOBuffer> buf4 =
1076 base::MakeRefCounted<StringIOBuffer>(kBody4);
1077 scoped_refptr<StringIOBuffer> buf5 =
1078 base::MakeRefCounted<StringIOBuffer>(kBody5);
1079
1080 delegate->SendvData({buf3, buf4, buf5},
1081 {buf3->size(), buf4->size(), buf5->size()}, kFin);
1082 delegate->WaitUntilNextCallback(kOnDataSent);
1083
1084 size_t spdy_trailers_frame_length;
1085 spdy::Http2HeaderBlock trailers;
1086 trailers["foo"] = "bar";
1087 // Server sends trailers.
1088 ProcessPacket(ConstructResponseTrailersPacket(4, kFin, trailers.Clone(),
1089 &spdy_trailers_frame_length));
1090
1091 delegate->WaitUntilNextCallback(kOnTrailersReceived);
1092 EXPECT_EQ(trailers, delegate->trailers());
1093 EXPECT_THAT(delegate->ReadData(cb.callback()), IsOk());
1094
1095 EXPECT_EQ(1, delegate->on_data_read_count());
1096 EXPECT_EQ(2, delegate->on_data_sent_count());
1097 EXPECT_EQ(kProtoQUIC, delegate->GetProtocol());
1098 EXPECT_EQ(static_cast<int64_t>(
1099 spdy_request_headers_frame_length + kBody1.length() +
1100 kBody2.length() + kBody3.length() + kBody4.length() +
1101 kBody5.length() + header.length() + header2.length() +
1102 header3.length() + header4.length() + header5.length()),
1103 delegate->GetTotalSentBytes());
1104 EXPECT_EQ(static_cast<int64_t>(spdy_response_headers_frame_length +
1105 strlen(kResponseBody) + header6.length() +
1106 spdy_trailers_frame_length),
1107 delegate->GetTotalReceivedBytes());
1108 }
1109
1110 // Tests that when request headers are delayed, SendData triggers coalescing of
1111 // request headers with data buffers.
TEST_P(BidirectionalStreamQuicImplTest,SendDataCoalesceDataBufferAndHeaderFrame)1112 TEST_P(BidirectionalStreamQuicImplTest,
1113 SendDataCoalesceDataBufferAndHeaderFrame) {
1114 SetRequest("POST", "/", DEFAULT_PRIORITY);
1115 size_t spdy_request_headers_frame_length;
1116 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
1117 AddWrite(ConstructInitialSettingsPacket());
1118 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE);
1119 const char kBody1[] = "here are some data";
1120 std::string header = ConstructDataHeader(strlen(kBody1));
1121 AddWrite(ConstructRequestHeadersAndMultipleDataFramesPacket(
1122 !kFin, DEFAULT_PRIORITY, &spdy_request_headers_frame_length,
1123 {header, kBody1}));
1124
1125 // Ack server's data packet.
1126 AddWrite(ConstructClientAckPacket(3, 1));
1127 const char kBody2[] = "really small";
1128 std::string header2 = ConstructDataHeader(strlen(kBody2));
1129 AddWrite(ConstructClientDataPacket(kFin, header2 + std::string(kBody2)));
1130
1131 Initialize();
1132
1133 BidirectionalStreamRequestInfo request;
1134 request.method = "POST";
1135 request.url = GURL("http://www.google.com/");
1136 request.end_stream_on_headers = false;
1137 request.priority = DEFAULT_PRIORITY;
1138
1139 auto read_buffer = base::MakeRefCounted<IOBufferWithSize>(kReadBufferSize);
1140 auto delegate =
1141 std::make_unique<TestDelegateBase>(read_buffer.get(), kReadBufferSize);
1142 delegate->DoNotSendRequestHeadersAutomatically();
1143 delegate->Start(&request, net_log_with_source(),
1144 session()->CreateHandle(destination_));
1145 ConfirmHandshake();
1146 delegate->WaitUntilNextCallback(kOnStreamReady);
1147
1148 // Send a Data packet.
1149 scoped_refptr<StringIOBuffer> buf1 =
1150 base::MakeRefCounted<StringIOBuffer>(kBody1);
1151
1152 delegate->SendData(buf1, buf1->size(), false);
1153 delegate->WaitUntilNextCallback(kOnDataSent);
1154
1155 // Server acks the request.
1156 ProcessPacket(ConstructServerAckPacket(1, 1, 1, 1));
1157
1158 // Server sends the response headers.
1159 spdy::Http2HeaderBlock response_headers = ConstructResponseHeaders("200");
1160 size_t spdy_response_headers_frame_length;
1161 ProcessPacket(
1162 ConstructResponseHeadersPacket(2, !kFin, std::move(response_headers),
1163 &spdy_response_headers_frame_length));
1164
1165 delegate->WaitUntilNextCallback(kOnHeadersReceived);
1166 TestCompletionCallback cb;
1167 int rv = delegate->ReadData(cb.callback());
1168 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1169 EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
1170 const char kResponseBody[] = "Hello world!";
1171 // Server sends data.
1172 std::string header3 = ConstructDataHeader(strlen(kResponseBody));
1173 ProcessPacket(ConstructServerDataPacket(3, !kFin, header3 + kResponseBody));
1174
1175 EXPECT_EQ(static_cast<int>(strlen(kResponseBody)), cb.WaitForResult());
1176
1177 // Send a second Data packet.
1178 scoped_refptr<StringIOBuffer> buf2 =
1179 base::MakeRefCounted<StringIOBuffer>(kBody2);
1180
1181 delegate->SendData(buf2, buf2->size(), true);
1182 delegate->WaitUntilNextCallback(kOnDataSent);
1183
1184 size_t spdy_trailers_frame_length;
1185 spdy::Http2HeaderBlock trailers;
1186 trailers["foo"] = "bar";
1187 // Server sends trailers.
1188 ProcessPacket(ConstructResponseTrailersPacket(4, kFin, trailers.Clone(),
1189 &spdy_trailers_frame_length));
1190
1191 delegate->WaitUntilNextCallback(kOnTrailersReceived);
1192 EXPECT_EQ(trailers, delegate->trailers());
1193 EXPECT_THAT(delegate->ReadData(cb.callback()), IsOk());
1194
1195 EXPECT_EQ(1, delegate->on_data_read_count());
1196 EXPECT_EQ(2, delegate->on_data_sent_count());
1197 EXPECT_EQ(kProtoQUIC, delegate->GetProtocol());
1198 EXPECT_EQ(
1199 static_cast<int64_t>(spdy_request_headers_frame_length + strlen(kBody1) +
1200 strlen(kBody2) + header.length() + header2.length()),
1201 delegate->GetTotalSentBytes());
1202 EXPECT_EQ(static_cast<int64_t>(spdy_response_headers_frame_length +
1203 strlen(kResponseBody) + header3.length() +
1204 spdy_trailers_frame_length),
1205 delegate->GetTotalReceivedBytes());
1206 }
1207
1208 // Tests that when request headers are delayed, SendvData triggers coalescing of
1209 // request headers with data buffers.
TEST_P(BidirectionalStreamQuicImplTest,SendvDataCoalesceDataBuffersAndHeaderFrame)1210 TEST_P(BidirectionalStreamQuicImplTest,
1211 SendvDataCoalesceDataBuffersAndHeaderFrame) {
1212 SetRequest("POST", "/", DEFAULT_PRIORITY);
1213 size_t spdy_request_headers_frame_length;
1214 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
1215 AddWrite(ConstructInitialSettingsPacket());
1216 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE);
1217 const std::string kBody1 = "here are some data";
1218 const std::string kBody2 = "data keep coming";
1219 std::string header = ConstructDataHeader(kBody1.length());
1220 std::string header2 = ConstructDataHeader(kBody2.length());
1221
1222 AddWrite(ConstructRequestHeadersAndMultipleDataFramesPacket(
1223 !kFin, DEFAULT_PRIORITY, &spdy_request_headers_frame_length,
1224 {header + kBody1 + header2 + kBody2}));
1225
1226 // Ack server's data packet.
1227 AddWrite(ConstructClientAckPacket(3, 1));
1228 const std::string kBody3 = "hello there";
1229 const std::string kBody4 = "another piece of small data";
1230 const std::string kBody5 = "really small";
1231 std::string header3 = ConstructDataHeader(kBody3.length());
1232 std::string header4 = ConstructDataHeader(kBody4.length());
1233 std::string header5 = ConstructDataHeader(kBody5.length());
1234 AddWrite(ConstructClientDataPacket(
1235 kFin, header3 + kBody3 + header4 + kBody4 + header5 + kBody5));
1236
1237 Initialize();
1238
1239 BidirectionalStreamRequestInfo request;
1240 request.method = "POST";
1241 request.url = GURL("http://www.google.com/");
1242 request.end_stream_on_headers = false;
1243 request.priority = DEFAULT_PRIORITY;
1244
1245 auto read_buffer = base::MakeRefCounted<IOBufferWithSize>(kReadBufferSize);
1246 auto delegate =
1247 std::make_unique<TestDelegateBase>(read_buffer.get(), kReadBufferSize);
1248 delegate->DoNotSendRequestHeadersAutomatically();
1249 delegate->Start(&request, net_log_with_source(),
1250 session()->CreateHandle(destination_));
1251 ConfirmHandshake();
1252 delegate->WaitUntilNextCallback(kOnStreamReady);
1253
1254 // Send a Data packet.
1255 scoped_refptr<StringIOBuffer> buf1 =
1256 base::MakeRefCounted<StringIOBuffer>(kBody1);
1257 scoped_refptr<StringIOBuffer> buf2 =
1258 base::MakeRefCounted<StringIOBuffer>(kBody2);
1259
1260 std::vector<int> lengths = {buf1->size(), buf2->size()};
1261 delegate->SendvData({buf1, buf2}, lengths, !kFin);
1262 delegate->WaitUntilNextCallback(kOnDataSent);
1263
1264 // Server acks the request.
1265 ProcessPacket(ConstructServerAckPacket(1, 1, 1, 1));
1266
1267 // Server sends the response headers.
1268 spdy::Http2HeaderBlock response_headers = ConstructResponseHeaders("200");
1269 size_t spdy_response_headers_frame_length;
1270 ProcessPacket(
1271 ConstructResponseHeadersPacket(2, !kFin, std::move(response_headers),
1272 &spdy_response_headers_frame_length));
1273
1274 delegate->WaitUntilNextCallback(kOnHeadersReceived);
1275 TestCompletionCallback cb;
1276 int rv = delegate->ReadData(cb.callback());
1277 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1278 EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
1279 const char kResponseBody[] = "Hello world!";
1280 std::string header6 = ConstructDataHeader(strlen(kResponseBody));
1281 // Server sends data.
1282 ProcessPacket(ConstructServerDataPacket(3, !kFin, header6 + kResponseBody));
1283
1284 EXPECT_EQ(static_cast<int>(strlen(kResponseBody)), cb.WaitForResult());
1285
1286 // Send a second Data packet.
1287 scoped_refptr<StringIOBuffer> buf3 =
1288 base::MakeRefCounted<StringIOBuffer>(kBody3);
1289 scoped_refptr<StringIOBuffer> buf4 =
1290 base::MakeRefCounted<StringIOBuffer>(kBody4);
1291 scoped_refptr<StringIOBuffer> buf5 =
1292 base::MakeRefCounted<StringIOBuffer>(kBody5);
1293
1294 delegate->SendvData({buf3, buf4, buf5},
1295 {buf3->size(), buf4->size(), buf5->size()}, kFin);
1296 delegate->WaitUntilNextCallback(kOnDataSent);
1297
1298 size_t spdy_trailers_frame_length;
1299 spdy::Http2HeaderBlock trailers;
1300 trailers["foo"] = "bar";
1301 // Server sends trailers.
1302 ProcessPacket(ConstructResponseTrailersPacket(4, kFin, trailers.Clone(),
1303 &spdy_trailers_frame_length));
1304
1305 delegate->WaitUntilNextCallback(kOnTrailersReceived);
1306 EXPECT_EQ(trailers, delegate->trailers());
1307 EXPECT_THAT(delegate->ReadData(cb.callback()), IsOk());
1308
1309 EXPECT_EQ(1, delegate->on_data_read_count());
1310 EXPECT_EQ(2, delegate->on_data_sent_count());
1311 EXPECT_EQ(kProtoQUIC, delegate->GetProtocol());
1312 EXPECT_EQ(static_cast<int64_t>(
1313 spdy_request_headers_frame_length + kBody1.length() +
1314 kBody2.length() + kBody3.length() + kBody4.length() +
1315 kBody5.length() + header.length() + header2.length() +
1316 header3.length() + header4.length() + header5.length()),
1317 delegate->GetTotalSentBytes());
1318 EXPECT_EQ(static_cast<int64_t>(spdy_response_headers_frame_length +
1319 strlen(kResponseBody) + header6.length() +
1320 spdy_trailers_frame_length),
1321 delegate->GetTotalReceivedBytes());
1322 }
1323
1324 // Tests that when request headers are delayed and SendData triggers the
1325 // headers to be sent, if that write fails the stream does not crash.
TEST_P(BidirectionalStreamQuicImplTest,SendDataWriteErrorCoalesceDataBufferAndHeaderFrame)1326 TEST_P(BidirectionalStreamQuicImplTest,
1327 SendDataWriteErrorCoalesceDataBufferAndHeaderFrame) {
1328 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
1329 AddWrite(ConstructInitialSettingsPacket());
1330 AddWriteError(SYNCHRONOUS, ERR_CONNECTION_REFUSED);
1331
1332 Initialize();
1333
1334 BidirectionalStreamRequestInfo request;
1335 request.method = "POST";
1336 request.url = GURL("http://www.google.com/");
1337 request.end_stream_on_headers = false;
1338 request.priority = DEFAULT_PRIORITY;
1339 request.extra_headers.SetHeader("cookie", std::string(2048, 'A'));
1340
1341 auto read_buffer = base::MakeRefCounted<IOBufferWithSize>(kReadBufferSize);
1342 auto delegate = std::make_unique<DeleteStreamDelegate>(
1343 read_buffer.get(), kReadBufferSize, DeleteStreamDelegate::ON_FAILED);
1344 delegate->DoNotSendRequestHeadersAutomatically();
1345 delegate->Start(&request, net_log_with_source(),
1346 session()->CreateHandle(destination_));
1347 ConfirmHandshake();
1348 delegate->WaitUntilNextCallback(kOnStreamReady);
1349
1350 // Attempt to send the headers and data.
1351 const char kBody1[] = "here are some data";
1352 scoped_refptr<StringIOBuffer> buf1 =
1353 base::MakeRefCounted<StringIOBuffer>(kBody1);
1354 delegate->SendData(buf1, buf1->size(), !kFin);
1355
1356 delegate->WaitUntilNextCallback(kOnFailed);
1357 }
1358
1359 // Tests that when request headers are delayed and SendvData triggers the
1360 // headers to be sent, if that write fails the stream does not crash.
TEST_P(BidirectionalStreamQuicImplTest,SendvDataWriteErrorCoalesceDataBufferAndHeaderFrame)1361 TEST_P(BidirectionalStreamQuicImplTest,
1362 SendvDataWriteErrorCoalesceDataBufferAndHeaderFrame) {
1363 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
1364 AddWrite(ConstructInitialSettingsPacket());
1365 AddWriteError(SYNCHRONOUS, ERR_CONNECTION_REFUSED);
1366
1367 Initialize();
1368
1369 BidirectionalStreamRequestInfo request;
1370 request.method = "POST";
1371 request.url = GURL("http://www.google.com/");
1372 request.end_stream_on_headers = false;
1373 request.priority = DEFAULT_PRIORITY;
1374 request.extra_headers.SetHeader("cookie", std::string(2048, 'A'));
1375
1376 auto read_buffer = base::MakeRefCounted<IOBufferWithSize>(kReadBufferSize);
1377 auto delegate = std::make_unique<DeleteStreamDelegate>(
1378 read_buffer.get(), kReadBufferSize, DeleteStreamDelegate::ON_FAILED);
1379 delegate->DoNotSendRequestHeadersAutomatically();
1380 delegate->Start(&request, net_log_with_source(),
1381 session()->CreateHandle(destination_));
1382 ConfirmHandshake();
1383 delegate->WaitUntilNextCallback(kOnStreamReady);
1384
1385 // Attempt to send the headers and data.
1386 const char kBody1[] = "here are some data";
1387 const char kBody2[] = "data keep coming";
1388 scoped_refptr<StringIOBuffer> buf1 =
1389 base::MakeRefCounted<StringIOBuffer>(kBody1);
1390 scoped_refptr<StringIOBuffer> buf2 =
1391 base::MakeRefCounted<StringIOBuffer>(kBody2);
1392 std::vector<int> lengths = {buf1->size(), buf2->size()};
1393 delegate->SendvData({buf1, buf2}, lengths, !kFin);
1394
1395 delegate->WaitUntilNextCallback(kOnFailed);
1396 }
1397
TEST_P(BidirectionalStreamQuicImplTest,PostRequest)1398 TEST_P(BidirectionalStreamQuicImplTest, PostRequest) {
1399 SetRequest("POST", "/", DEFAULT_PRIORITY);
1400 size_t spdy_request_headers_frame_length;
1401 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
1402 AddWrite(ConstructInitialSettingsPacket());
1403 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE);
1404 AddWrite(ConstructRequestHeadersPacketInner(
1405 GetNthClientInitiatedBidirectionalStreamId(0), !kFin, DEFAULT_PRIORITY,
1406 &spdy_request_headers_frame_length));
1407 std::string header = ConstructDataHeader(strlen(kUploadData));
1408 AddWrite(ConstructClientDataPacket(kFin, header + std::string(kUploadData)));
1409
1410 AddWrite(ConstructClientAckPacket(3, 1));
1411
1412 Initialize();
1413
1414 BidirectionalStreamRequestInfo request;
1415 request.method = "POST";
1416 request.url = GURL("http://www.google.com/");
1417 request.end_stream_on_headers = false;
1418 request.priority = DEFAULT_PRIORITY;
1419
1420 auto read_buffer = base::MakeRefCounted<IOBufferWithSize>(kReadBufferSize);
1421 auto delegate =
1422 std::make_unique<TestDelegateBase>(read_buffer.get(), kReadBufferSize);
1423 delegate->Start(&request, net_log_with_source(),
1424 session()->CreateHandle(destination_));
1425 ConfirmHandshake();
1426 delegate->WaitUntilNextCallback(kOnStreamReady);
1427
1428 // Send a DATA frame.
1429 scoped_refptr<StringIOBuffer> buf =
1430 base::MakeRefCounted<StringIOBuffer>(kUploadData);
1431
1432 delegate->SendData(buf, buf->size(), true);
1433 delegate->WaitUntilNextCallback(kOnDataSent);
1434
1435 // Server acks the request.
1436 ProcessPacket(ConstructServerAckPacket(1, 1, 1, 1));
1437
1438 // Server sends the response headers.
1439 spdy::Http2HeaderBlock response_headers = ConstructResponseHeaders("200");
1440 size_t spdy_response_headers_frame_length;
1441 ProcessPacket(
1442 ConstructResponseHeadersPacket(2, !kFin, std::move(response_headers),
1443 &spdy_response_headers_frame_length));
1444
1445 delegate->WaitUntilNextCallback(kOnHeadersReceived);
1446 TestCompletionCallback cb;
1447 int rv = delegate->ReadData(cb.callback());
1448 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1449 EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
1450 const char kResponseBody[] = "Hello world!";
1451 std::string header2 = ConstructDataHeader(strlen(kResponseBody));
1452 // Server sends data.
1453 ProcessPacket(ConstructServerDataPacket(3, !kFin, header2 + kResponseBody));
1454
1455 EXPECT_EQ(static_cast<int>(strlen(kResponseBody)), cb.WaitForResult());
1456
1457 size_t spdy_trailers_frame_length;
1458 spdy::Http2HeaderBlock trailers;
1459 trailers["foo"] = "bar";
1460 // Server sends trailers.
1461 ProcessPacket(ConstructResponseTrailersPacket(4, kFin, trailers.Clone(),
1462 &spdy_trailers_frame_length));
1463
1464 delegate->WaitUntilNextCallback(kOnTrailersReceived);
1465 EXPECT_EQ(trailers, delegate->trailers());
1466 EXPECT_THAT(delegate->ReadData(cb.callback()), IsOk());
1467
1468 EXPECT_EQ(1, delegate->on_data_read_count());
1469 EXPECT_EQ(1, delegate->on_data_sent_count());
1470 EXPECT_EQ(kProtoQUIC, delegate->GetProtocol());
1471 EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length +
1472 strlen(kUploadData) + header.length()),
1473 delegate->GetTotalSentBytes());
1474 EXPECT_EQ(static_cast<int64_t>(spdy_response_headers_frame_length +
1475 strlen(kResponseBody) + header2.length() +
1476 spdy_trailers_frame_length),
1477 delegate->GetTotalReceivedBytes());
1478 }
1479
TEST_P(BidirectionalStreamQuicImplTest,EarlyDataOverrideRequest)1480 TEST_P(BidirectionalStreamQuicImplTest, EarlyDataOverrideRequest) {
1481 SetRequest("PUT", "/", DEFAULT_PRIORITY);
1482 size_t spdy_request_headers_frame_length;
1483 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
1484 AddWrite(ConstructInitialSettingsPacket());
1485 AddWrite(ConstructRequestHeadersPacketInner(
1486 GetNthClientInitiatedBidirectionalStreamId(0), kFin, DEFAULT_PRIORITY,
1487 &spdy_request_headers_frame_length));
1488 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE);
1489 AddWrite(ConstructClientAckPacket(3, 1));
1490
1491 Initialize();
1492
1493 BidirectionalStreamRequestInfo request;
1494 request.method = "PUT";
1495 request.allow_early_data_override = true;
1496 request.url = GURL("http://www.google.com/");
1497 request.end_stream_on_headers = true;
1498 request.priority = DEFAULT_PRIORITY;
1499
1500 auto read_buffer = base::MakeRefCounted<IOBufferWithSize>(kReadBufferSize);
1501 auto delegate =
1502 std::make_unique<TestDelegateBase>(read_buffer.get(), kReadBufferSize);
1503 delegate->set_trailers_expected(true);
1504 delegate->Start(&request, net_log_with_source(),
1505 session()->CreateHandle(destination_));
1506 delegate->WaitUntilNextCallback(kOnStreamReady);
1507 ConfirmHandshake();
1508
1509 // Server acks the request.
1510 ProcessPacket(ConstructServerAckPacket(1, 1, 1, 1));
1511
1512 // Server sends the response headers.
1513 spdy::Http2HeaderBlock response_headers = ConstructResponseHeaders("200");
1514
1515 size_t spdy_response_headers_frame_length;
1516 ProcessPacket(
1517 ConstructResponseHeadersPacket(2, !kFin, std::move(response_headers),
1518 &spdy_response_headers_frame_length));
1519
1520 delegate->WaitUntilNextCallback(kOnHeadersReceived);
1521 LoadTimingInfo load_timing_info;
1522 EXPECT_TRUE(delegate->GetLoadTimingInfo(&load_timing_info));
1523 ExpectLoadTimingValid(load_timing_info, /*session_reused=*/false);
1524 TestCompletionCallback cb;
1525 int rv = delegate->ReadData(cb.callback());
1526 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1527 EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
1528 const char kResponseBody[] = "Hello world!";
1529 // Server sends data.
1530 std::string header = ConstructDataHeader(strlen(kResponseBody));
1531 ProcessPacket(ConstructServerDataPacket(3, !kFin, header + kResponseBody));
1532 EXPECT_EQ(12, cb.WaitForResult());
1533
1534 EXPECT_EQ(std::string(kResponseBody), delegate->data_received());
1535 TestCompletionCallback cb2;
1536 EXPECT_THAT(delegate->ReadData(cb2.callback()), IsError(ERR_IO_PENDING));
1537
1538 spdy::Http2HeaderBlock trailers;
1539 size_t spdy_trailers_frame_length;
1540 trailers["foo"] = "bar";
1541 // Server sends trailers.
1542 ProcessPacket(ConstructResponseTrailersPacket(4, kFin, trailers.Clone(),
1543 &spdy_trailers_frame_length));
1544
1545 delegate->WaitUntilNextCallback(kOnTrailersReceived);
1546 EXPECT_THAT(cb2.WaitForResult(), IsOk());
1547 EXPECT_EQ(trailers, delegate->trailers());
1548
1549 EXPECT_THAT(delegate->ReadData(cb2.callback()), IsOk());
1550 base::RunLoop().RunUntilIdle();
1551
1552 EXPECT_EQ(2, delegate->on_data_read_count());
1553 EXPECT_EQ(0, delegate->on_data_sent_count());
1554 EXPECT_EQ(kProtoQUIC, delegate->GetProtocol());
1555 EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length),
1556 delegate->GetTotalSentBytes());
1557 EXPECT_EQ(static_cast<int64_t>(spdy_response_headers_frame_length +
1558 strlen(kResponseBody) + header.length() +
1559 spdy_trailers_frame_length),
1560 delegate->GetTotalReceivedBytes());
1561 // Check that NetLog was filled as expected.
1562 auto entries = net_log_observer().GetEntries();
1563 size_t pos = ExpectLogContainsSomewhere(
1564 entries, /*min_offset=*/0,
1565 NetLogEventType::QUIC_CHROMIUM_CLIENT_STREAM_SEND_REQUEST_HEADERS,
1566 NetLogEventPhase::NONE);
1567 pos = ExpectLogContainsSomewhere(
1568 entries, /*min_offset=*/pos,
1569 NetLogEventType::QUIC_CHROMIUM_CLIENT_STREAM_SEND_REQUEST_HEADERS,
1570 NetLogEventPhase::NONE);
1571 ExpectLogContainsSomewhere(
1572 entries, /*min_offset=*/pos,
1573 NetLogEventType::QUIC_CHROMIUM_CLIENT_STREAM_SEND_REQUEST_HEADERS,
1574 NetLogEventPhase::NONE);
1575 }
1576
TEST_P(BidirectionalStreamQuicImplTest,InterleaveReadDataAndSendData)1577 TEST_P(BidirectionalStreamQuicImplTest, InterleaveReadDataAndSendData) {
1578 SetRequest("POST", "/", DEFAULT_PRIORITY);
1579 size_t spdy_request_headers_frame_length;
1580 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
1581 AddWrite(ConstructInitialSettingsPacket());
1582 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE);
1583 AddWrite(ConstructRequestHeadersPacketInner(
1584 GetNthClientInitiatedBidirectionalStreamId(0), !kFin, DEFAULT_PRIORITY,
1585 &spdy_request_headers_frame_length));
1586
1587 std::string header = ConstructDataHeader(strlen(kUploadData));
1588 AddWrite(ConstructAckAndDataPacket(++packet_number_, 2, 1, !kFin,
1589 header + std::string(kUploadData),
1590 &client_maker_));
1591 AddWrite(ConstructAckAndDataPacket(++packet_number_, 3, 3, kFin,
1592 header + std::string(kUploadData),
1593 &client_maker_));
1594 Initialize();
1595
1596 BidirectionalStreamRequestInfo request;
1597 request.method = "POST";
1598 request.url = GURL("http://www.google.com/");
1599 request.end_stream_on_headers = false;
1600 request.priority = DEFAULT_PRIORITY;
1601
1602 auto read_buffer = base::MakeRefCounted<IOBufferWithSize>(kReadBufferSize);
1603 auto delegate =
1604 std::make_unique<TestDelegateBase>(read_buffer.get(), kReadBufferSize);
1605 delegate->Start(&request, net_log_with_source(),
1606 session()->CreateHandle(destination_));
1607 ConfirmHandshake();
1608 delegate->WaitUntilNextCallback(kOnStreamReady);
1609
1610 // Server acks the request.
1611 ProcessPacket(ConstructServerAckPacket(1, 1, 1, 1));
1612
1613 // Server sends the response headers.
1614 spdy::Http2HeaderBlock response_headers = ConstructResponseHeaders("200");
1615 size_t spdy_response_headers_frame_length;
1616 ProcessPacket(
1617 ConstructResponseHeadersPacket(2, !kFin, std::move(response_headers),
1618 &spdy_response_headers_frame_length));
1619
1620 delegate->WaitUntilNextCallback(kOnHeadersReceived);
1621 EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
1622
1623 // Client sends a data packet.
1624 scoped_refptr<StringIOBuffer> buf =
1625 base::MakeRefCounted<StringIOBuffer>(kUploadData);
1626
1627 delegate->SendData(buf, buf->size(), false);
1628 delegate->WaitUntilNextCallback(kOnDataSent);
1629
1630 TestCompletionCallback cb;
1631 int rv = delegate->ReadData(cb.callback());
1632 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1633 const char kResponseBody[] = "Hello world!";
1634
1635 std::string header2 = ConstructDataHeader(strlen(kResponseBody));
1636 // Server sends a data packet
1637 int server_ack = 2;
1638 ProcessPacket(ConstructAckAndDataPacket(
1639 3, server_ack++, 1, !kFin, header2 + kResponseBody, &server_maker_));
1640
1641 EXPECT_EQ(static_cast<int64_t>(strlen(kResponseBody)), cb.WaitForResult());
1642 EXPECT_EQ(std::string(kResponseBody), delegate->data_received());
1643
1644 // Client sends a data packet.
1645 delegate->SendData(buf, buf->size(), true);
1646 delegate->WaitUntilNextCallback(kOnDataSent);
1647
1648 TestCompletionCallback cb2;
1649 rv = delegate->ReadData(cb2.callback());
1650 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1651 ProcessPacket(ConstructAckAndDataPacket(4, server_ack++, 1, kFin,
1652
1653 header2 + kResponseBody,
1654 &server_maker_));
1655
1656 EXPECT_EQ(static_cast<int64_t>(strlen(kResponseBody)), cb2.WaitForResult());
1657
1658 std::string expected_body(kResponseBody);
1659 expected_body.append(kResponseBody);
1660 EXPECT_EQ(expected_body, delegate->data_received());
1661
1662 EXPECT_THAT(delegate->ReadData(cb.callback()), IsOk());
1663 EXPECT_EQ(2, delegate->on_data_read_count());
1664 EXPECT_EQ(2, delegate->on_data_sent_count());
1665 EXPECT_EQ(kProtoQUIC, delegate->GetProtocol());
1666 EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length +
1667 2 * strlen(kUploadData) + 2 * header.length()),
1668 delegate->GetTotalSentBytes());
1669 EXPECT_EQ(
1670 static_cast<int64_t>(spdy_response_headers_frame_length +
1671 2 * strlen(kResponseBody) + 2 * header2.length()),
1672 delegate->GetTotalReceivedBytes());
1673 }
1674
TEST_P(BidirectionalStreamQuicImplTest,ServerSendsRstAfterHeaders)1675 TEST_P(BidirectionalStreamQuicImplTest, ServerSendsRstAfterHeaders) {
1676 SetRequest("GET", "/", DEFAULT_PRIORITY);
1677 size_t spdy_request_headers_frame_length;
1678 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
1679 AddWrite(ConstructInitialSettingsPacket());
1680 AddWrite(ConstructRequestHeadersPacketInner(
1681 GetNthClientInitiatedBidirectionalStreamId(0), kFin, DEFAULT_PRIORITY,
1682 &spdy_request_headers_frame_length));
1683 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE);
1684 Initialize();
1685
1686 BidirectionalStreamRequestInfo request;
1687 request.method = "GET";
1688 request.url = GURL("http://www.google.com/");
1689 request.end_stream_on_headers = true;
1690 request.priority = DEFAULT_PRIORITY;
1691
1692 auto read_buffer = base::MakeRefCounted<IOBufferWithSize>(kReadBufferSize);
1693 auto delegate =
1694 std::make_unique<TestDelegateBase>(read_buffer.get(), kReadBufferSize);
1695 delegate->Start(&request, net_log_with_source(),
1696 session()->CreateHandle(destination_));
1697 delegate->WaitUntilNextCallback(kOnStreamReady);
1698 ConfirmHandshake();
1699
1700 // Server sends a Rst. Since the stream has sent fin, the rst is one way in
1701 // IETF QUIC.
1702 ProcessPacket(server_maker_.MakeRstPacket(
1703 1, GetNthClientInitiatedBidirectionalStreamId(0),
1704 quic::QUIC_STREAM_CANCELLED,
1705 /*include_stop_sending_if_v99=*/false));
1706
1707 delegate->WaitUntilNextCallback(kOnFailed);
1708
1709 TestCompletionCallback cb;
1710 EXPECT_THAT(delegate->ReadData(cb.callback()),
1711 IsError(ERR_QUIC_PROTOCOL_ERROR));
1712
1713 base::RunLoop().RunUntilIdle();
1714
1715 EXPECT_THAT(delegate->error(), IsError(ERR_QUIC_PROTOCOL_ERROR));
1716 EXPECT_EQ(0, delegate->on_data_read_count());
1717 EXPECT_EQ(0, delegate->on_data_sent_count());
1718 EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length),
1719 delegate->GetTotalSentBytes());
1720 EXPECT_EQ(0, delegate->GetTotalReceivedBytes());
1721 }
1722
TEST_P(BidirectionalStreamQuicImplTest,ServerSendsRstAfterReadData)1723 TEST_P(BidirectionalStreamQuicImplTest, ServerSendsRstAfterReadData) {
1724 SetRequest("GET", "/", DEFAULT_PRIORITY);
1725 size_t spdy_request_headers_frame_length;
1726 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
1727 AddWrite(ConstructInitialSettingsPacket());
1728 AddWrite(ConstructRequestHeadersPacketInner(
1729 GetNthClientInitiatedBidirectionalStreamId(0), kFin, DEFAULT_PRIORITY,
1730 &spdy_request_headers_frame_length));
1731 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE);
1732 // Why does QUIC ack Rst? Is this expected?
1733 AddWrite(ConstructClientAckPacket(3, 1));
1734
1735 Initialize();
1736
1737 BidirectionalStreamRequestInfo request;
1738 request.method = "GET";
1739 request.url = GURL("http://www.google.com/");
1740 request.end_stream_on_headers = true;
1741 request.priority = DEFAULT_PRIORITY;
1742
1743 auto read_buffer = base::MakeRefCounted<IOBufferWithSize>(kReadBufferSize);
1744 auto delegate =
1745 std::make_unique<TestDelegateBase>(read_buffer.get(), kReadBufferSize);
1746 delegate->Start(&request, net_log_with_source(),
1747 session()->CreateHandle(destination_));
1748 delegate->WaitUntilNextCallback(kOnStreamReady);
1749 ConfirmHandshake();
1750
1751 // Server acks the request.
1752 ProcessPacket(ConstructServerAckPacket(1, 1, 1, 1));
1753
1754 // Server sends the response headers.
1755 spdy::Http2HeaderBlock response_headers = ConstructResponseHeaders("200");
1756
1757 size_t spdy_response_headers_frame_length;
1758 ProcessPacket(
1759 ConstructResponseHeadersPacket(2, !kFin, std::move(response_headers),
1760 &spdy_response_headers_frame_length));
1761
1762 delegate->WaitUntilNextCallback(kOnHeadersReceived);
1763 EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
1764
1765 TestCompletionCallback cb;
1766 int rv = delegate->ReadData(cb.callback());
1767 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1768
1769 // Server sends a Rst. Since the stream has sent fin, the rst is one way in
1770 // IETF QUIC.
1771 ProcessPacket(server_maker_.MakeRstPacket(
1772 3, GetNthClientInitiatedBidirectionalStreamId(0),
1773 quic::QUIC_STREAM_CANCELLED,
1774 /*include_stop_sending_if_v99=*/false));
1775
1776 delegate->WaitUntilNextCallback(kOnFailed);
1777
1778 EXPECT_THAT(delegate->ReadData(cb.callback()),
1779 IsError(ERR_QUIC_PROTOCOL_ERROR));
1780 EXPECT_THAT(delegate->error(), IsError(ERR_QUIC_PROTOCOL_ERROR));
1781 EXPECT_EQ(0, delegate->on_data_read_count());
1782 EXPECT_EQ(0, delegate->on_data_sent_count());
1783 EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length),
1784 delegate->GetTotalSentBytes());
1785 EXPECT_EQ(static_cast<int64_t>(spdy_response_headers_frame_length),
1786 delegate->GetTotalReceivedBytes());
1787 }
1788
TEST_P(BidirectionalStreamQuicImplTest,SessionClosedBeforeReadData)1789 TEST_P(BidirectionalStreamQuicImplTest, SessionClosedBeforeReadData) {
1790 SetRequest("POST", "/", DEFAULT_PRIORITY);
1791 size_t spdy_request_headers_frame_length;
1792 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
1793 AddWrite(ConstructInitialSettingsPacket());
1794 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE);
1795 AddWrite(ConstructRequestHeadersPacketInner(
1796 GetNthClientInitiatedBidirectionalStreamId(0), !kFin, DEFAULT_PRIORITY,
1797 &spdy_request_headers_frame_length));
1798 Initialize();
1799
1800 BidirectionalStreamRequestInfo request;
1801 request.method = "POST";
1802 request.url = GURL("http://www.google.com/");
1803 request.end_stream_on_headers = false;
1804 request.priority = DEFAULT_PRIORITY;
1805
1806 auto read_buffer = base::MakeRefCounted<IOBufferWithSize>(kReadBufferSize);
1807 auto delegate =
1808 std::make_unique<TestDelegateBase>(read_buffer.get(), kReadBufferSize);
1809 delegate->Start(&request, net_log_with_source(),
1810 session()->CreateHandle(destination_));
1811 ConfirmHandshake();
1812 delegate->WaitUntilNextCallback(kOnStreamReady);
1813
1814 // Server acks the request.
1815 ProcessPacket(ConstructServerAckPacket(1, 1, 1, 1));
1816
1817 // Server sends the response headers.
1818 spdy::Http2HeaderBlock response_headers = ConstructResponseHeaders("200");
1819
1820 size_t spdy_response_headers_frame_length;
1821 ProcessPacket(
1822 ConstructResponseHeadersPacket(2, !kFin, std::move(response_headers),
1823 &spdy_response_headers_frame_length));
1824
1825 delegate->WaitUntilNextCallback(kOnHeadersReceived);
1826 TestCompletionCallback cb;
1827 int rv = delegate->ReadData(cb.callback());
1828 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1829 session()->connection()->CloseConnection(
1830 quic::QUIC_NO_ERROR, "test", quic::ConnectionCloseBehavior::SILENT_CLOSE);
1831 delegate->WaitUntilNextCallback(kOnFailed);
1832
1833 // Try to send data after OnFailed(), should not get called back.
1834 scoped_refptr<StringIOBuffer> buf =
1835 base::MakeRefCounted<StringIOBuffer>(kUploadData);
1836 delegate->SendData(buf, buf->size(), false);
1837
1838 EXPECT_THAT(delegate->ReadData(cb.callback()),
1839 IsError(ERR_QUIC_PROTOCOL_ERROR));
1840 EXPECT_THAT(delegate->error(), IsError(ERR_QUIC_PROTOCOL_ERROR));
1841 EXPECT_EQ(0, delegate->on_data_read_count());
1842 EXPECT_EQ(0, delegate->on_data_sent_count());
1843 EXPECT_EQ(kProtoQUIC, delegate->GetProtocol());
1844 EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length),
1845 delegate->GetTotalSentBytes());
1846 EXPECT_EQ(static_cast<int64_t>(spdy_response_headers_frame_length),
1847 delegate->GetTotalReceivedBytes());
1848 }
1849
TEST_P(BidirectionalStreamQuicImplTest,SessionClosedBeforeStartConfirmed)1850 TEST_P(BidirectionalStreamQuicImplTest, SessionClosedBeforeStartConfirmed) {
1851 SetRequest("POST", "/", DEFAULT_PRIORITY);
1852 Initialize();
1853
1854 BidirectionalStreamRequestInfo request;
1855 request.method = "POST";
1856 request.url = GURL("http://www.google.com/");
1857 request.end_stream_on_headers = false;
1858 request.priority = DEFAULT_PRIORITY;
1859
1860 ConfirmHandshake();
1861 session()->connection()->CloseConnection(
1862 quic::QUIC_NO_ERROR, "test", quic::ConnectionCloseBehavior::SILENT_CLOSE);
1863
1864 auto read_buffer = base::MakeRefCounted<IOBufferWithSize>(kReadBufferSize);
1865 auto delegate =
1866 std::make_unique<TestDelegateBase>(read_buffer.get(), kReadBufferSize);
1867 delegate->Start(&request, net_log_with_source(),
1868 session()->CreateHandle(destination_));
1869 delegate->WaitUntilNextCallback(kOnFailed);
1870 EXPECT_TRUE(delegate->on_failed_called());
1871 EXPECT_THAT(delegate->error(), IsError(ERR_CONNECTION_CLOSED));
1872 }
1873
TEST_P(BidirectionalStreamQuicImplTest,SessionClosedBeforeStartNotConfirmed)1874 TEST_P(BidirectionalStreamQuicImplTest, SessionClosedBeforeStartNotConfirmed) {
1875 SetRequest("POST", "/", DEFAULT_PRIORITY);
1876 Initialize();
1877
1878 session()->connection()->CloseConnection(
1879 quic::QUIC_NO_ERROR, "test", quic::ConnectionCloseBehavior::SILENT_CLOSE);
1880
1881 BidirectionalStreamRequestInfo request;
1882 request.method = "POST";
1883 request.url = GURL("http://www.google.com/");
1884 request.end_stream_on_headers = false;
1885 request.priority = DEFAULT_PRIORITY;
1886
1887 auto read_buffer = base::MakeRefCounted<IOBufferWithSize>(kReadBufferSize);
1888 auto delegate =
1889 std::make_unique<TestDelegateBase>(read_buffer.get(), kReadBufferSize);
1890 delegate->Start(&request, net_log_with_source(),
1891 session()->CreateHandle(destination_));
1892 delegate->WaitUntilNextCallback(kOnFailed);
1893 EXPECT_TRUE(delegate->on_failed_called());
1894 EXPECT_THAT(delegate->error(), IsError(ERR_QUIC_HANDSHAKE_FAILED));
1895 }
1896
TEST_P(BidirectionalStreamQuicImplTest,SessionCloseDuringOnStreamReady)1897 TEST_P(BidirectionalStreamQuicImplTest, SessionCloseDuringOnStreamReady) {
1898 SetRequest("POST", "/", DEFAULT_PRIORITY);
1899 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
1900 AddWrite(ConstructInitialSettingsPacket());
1901 AddWriteError(SYNCHRONOUS, ERR_CONNECTION_REFUSED);
1902
1903 Initialize();
1904
1905 BidirectionalStreamRequestInfo request;
1906 request.method = "POST";
1907 request.url = GURL("http://www.google.com/");
1908 request.end_stream_on_headers = false;
1909 request.priority = DEFAULT_PRIORITY;
1910
1911 auto read_buffer = base::MakeRefCounted<IOBufferWithSize>(kReadBufferSize);
1912 auto delegate = std::make_unique<DeleteStreamDelegate>(
1913 read_buffer.get(), kReadBufferSize, DeleteStreamDelegate::ON_FAILED);
1914 delegate->Start(&request, net_log_with_source(),
1915 session()->CreateHandle(destination_));
1916 ConfirmHandshake();
1917 delegate->WaitUntilNextCallback(kOnFailed);
1918
1919 EXPECT_EQ(0, delegate->on_data_read_count());
1920 EXPECT_EQ(0, delegate->on_data_sent_count());
1921 }
1922
TEST_P(BidirectionalStreamQuicImplTest,DeleteStreamDuringOnStreamReady)1923 TEST_P(BidirectionalStreamQuicImplTest, DeleteStreamDuringOnStreamReady) {
1924 SetRequest("POST", "/", DEFAULT_PRIORITY);
1925 size_t spdy_request_headers_frame_length;
1926 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
1927 AddWrite(ConstructInitialSettingsPacket());
1928 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE);
1929 AddWrite(ConstructRequestHeadersPacketInner(
1930 GetNthClientInitiatedBidirectionalStreamId(0), !kFin, DEFAULT_PRIORITY,
1931 &spdy_request_headers_frame_length));
1932 AddWrite(ConstructClientEarlyRstStreamPacket());
1933
1934 Initialize();
1935
1936 BidirectionalStreamRequestInfo request;
1937 request.method = "POST";
1938 request.url = GURL("http://www.google.com/");
1939 request.end_stream_on_headers = false;
1940 request.priority = DEFAULT_PRIORITY;
1941
1942 auto read_buffer = base::MakeRefCounted<IOBufferWithSize>(kReadBufferSize);
1943 auto delegate = std::make_unique<DeleteStreamDelegate>(
1944 read_buffer.get(), kReadBufferSize,
1945 DeleteStreamDelegate::ON_STREAM_READY);
1946 delegate->Start(&request, net_log_with_source(),
1947 session()->CreateHandle(destination_));
1948 ConfirmHandshake();
1949 delegate->WaitUntilNextCallback(kOnStreamReady);
1950
1951 EXPECT_EQ(0, delegate->on_data_read_count());
1952 EXPECT_EQ(0, delegate->on_data_sent_count());
1953 }
1954
TEST_P(BidirectionalStreamQuicImplTest,DeleteStreamAfterReadData)1955 TEST_P(BidirectionalStreamQuicImplTest, DeleteStreamAfterReadData) {
1956 SetRequest("POST", "/", DEFAULT_PRIORITY);
1957 size_t spdy_request_headers_frame_length;
1958 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
1959 AddWrite(ConstructInitialSettingsPacket());
1960 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE);
1961 AddWrite(ConstructRequestHeadersPacketInner(
1962 GetNthClientInitiatedBidirectionalStreamId(0), !kFin, DEFAULT_PRIORITY,
1963 &spdy_request_headers_frame_length));
1964 AddWrite(ConstructClientAckAndRstStreamPacket(2, 1));
1965
1966 Initialize();
1967
1968 BidirectionalStreamRequestInfo request;
1969 request.method = "POST";
1970 request.url = GURL("http://www.google.com/");
1971 request.end_stream_on_headers = false;
1972 request.priority = DEFAULT_PRIORITY;
1973
1974 auto read_buffer = base::MakeRefCounted<IOBufferWithSize>(kReadBufferSize);
1975 auto delegate =
1976 std::make_unique<TestDelegateBase>(read_buffer.get(), kReadBufferSize);
1977 delegate->Start(&request, net_log_with_source(),
1978 session()->CreateHandle(destination_));
1979 ConfirmHandshake();
1980 delegate->WaitUntilNextCallback(kOnStreamReady);
1981
1982 // Server acks the request.
1983 ProcessPacket(ConstructServerAckPacket(1, 1, 1, 1));
1984
1985 // Server sends the response headers.
1986 spdy::Http2HeaderBlock response_headers = ConstructResponseHeaders("200");
1987 size_t spdy_response_headers_frame_length;
1988 ProcessPacket(
1989 ConstructResponseHeadersPacket(2, !kFin, std::move(response_headers),
1990 &spdy_response_headers_frame_length));
1991
1992 delegate->WaitUntilNextCallback(kOnHeadersReceived);
1993 EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
1994
1995 // Cancel the stream after ReadData returns ERR_IO_PENDING.
1996 TestCompletionCallback cb;
1997 EXPECT_THAT(delegate->ReadData(cb.callback()), IsError(ERR_IO_PENDING));
1998 delegate->DeleteStream();
1999
2000 base::RunLoop().RunUntilIdle();
2001
2002 EXPECT_EQ(0, delegate->on_data_read_count());
2003 EXPECT_EQ(0, delegate->on_data_sent_count());
2004 EXPECT_EQ(kProtoQUIC, delegate->GetProtocol());
2005 EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length),
2006 delegate->GetTotalSentBytes());
2007 EXPECT_EQ(static_cast<int64_t>(spdy_response_headers_frame_length),
2008 delegate->GetTotalReceivedBytes());
2009 }
2010
TEST_P(BidirectionalStreamQuicImplTest,DeleteStreamDuringOnHeadersReceived)2011 TEST_P(BidirectionalStreamQuicImplTest, DeleteStreamDuringOnHeadersReceived) {
2012 SetRequest("POST", "/", DEFAULT_PRIORITY);
2013 size_t spdy_request_headers_frame_length;
2014 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
2015 AddWrite(ConstructInitialSettingsPacket());
2016 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE);
2017 AddWrite(ConstructRequestHeadersPacketInner(
2018 GetNthClientInitiatedBidirectionalStreamId(0), !kFin, DEFAULT_PRIORITY,
2019 &spdy_request_headers_frame_length));
2020 AddWrite(ConstructClientAckAndRstStreamPacket(2, 1));
2021
2022 Initialize();
2023
2024 BidirectionalStreamRequestInfo request;
2025 request.method = "POST";
2026 request.url = GURL("http://www.google.com/");
2027 request.end_stream_on_headers = false;
2028 request.priority = DEFAULT_PRIORITY;
2029
2030 auto read_buffer = base::MakeRefCounted<IOBufferWithSize>(kReadBufferSize);
2031 auto delegate = std::make_unique<DeleteStreamDelegate>(
2032 read_buffer.get(), kReadBufferSize,
2033 DeleteStreamDelegate::ON_HEADERS_RECEIVED);
2034 delegate->Start(&request, net_log_with_source(),
2035 session()->CreateHandle(destination_));
2036 ConfirmHandshake();
2037 delegate->WaitUntilNextCallback(kOnStreamReady);
2038
2039 // Server acks the request.
2040 ProcessPacket(ConstructServerAckPacket(1, 1, 1, 1));
2041
2042 // Server sends the response headers.
2043 spdy::Http2HeaderBlock response_headers = ConstructResponseHeaders("200");
2044
2045 size_t spdy_response_headers_frame_length;
2046 ProcessPacket(
2047 ConstructResponseHeadersPacket(2, !kFin, std::move(response_headers),
2048 &spdy_response_headers_frame_length));
2049
2050 delegate->WaitUntilNextCallback(kOnHeadersReceived);
2051 EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
2052
2053 base::RunLoop().RunUntilIdle();
2054
2055 EXPECT_EQ(0, delegate->on_data_read_count());
2056 EXPECT_EQ(0, delegate->on_data_sent_count());
2057 }
2058
TEST_P(BidirectionalStreamQuicImplTest,DeleteStreamDuringOnDataRead)2059 TEST_P(BidirectionalStreamQuicImplTest, DeleteStreamDuringOnDataRead) {
2060 SetRequest("POST", "/", DEFAULT_PRIORITY);
2061 size_t spdy_request_headers_frame_length;
2062 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
2063 AddWrite(ConstructInitialSettingsPacket());
2064 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE);
2065 AddWrite(ConstructRequestHeadersPacketInner(
2066 GetNthClientInitiatedBidirectionalStreamId(0), !kFin, DEFAULT_PRIORITY,
2067 &spdy_request_headers_frame_length));
2068 AddWrite(ConstructClientAckPacket(3, 1));
2069 AddWrite(ConstructClientRstStreamPacket());
2070
2071 Initialize();
2072
2073 BidirectionalStreamRequestInfo request;
2074 request.method = "POST";
2075 request.url = GURL("http://www.google.com/");
2076 request.end_stream_on_headers = false;
2077 request.priority = DEFAULT_PRIORITY;
2078
2079 auto read_buffer = base::MakeRefCounted<IOBufferWithSize>(kReadBufferSize);
2080 auto delegate = std::make_unique<DeleteStreamDelegate>(
2081 read_buffer.get(), kReadBufferSize, DeleteStreamDelegate::ON_DATA_READ);
2082 delegate->Start(&request, net_log_with_source(),
2083 session()->CreateHandle(destination_));
2084 ConfirmHandshake();
2085 delegate->WaitUntilNextCallback(kOnStreamReady);
2086
2087 // Server acks the request.
2088 ProcessPacket(ConstructServerAckPacket(1, 1, 1, 1));
2089
2090 // Server sends the response headers.
2091 spdy::Http2HeaderBlock response_headers = ConstructResponseHeaders("200");
2092
2093 size_t spdy_response_headers_frame_length;
2094 ProcessPacket(
2095 ConstructResponseHeadersPacket(2, !kFin, std::move(response_headers),
2096 &spdy_response_headers_frame_length));
2097
2098 delegate->WaitUntilNextCallback(kOnHeadersReceived);
2099
2100 EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
2101
2102 TestCompletionCallback cb;
2103 int rv = delegate->ReadData(cb.callback());
2104 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
2105 const char kResponseBody[] = "Hello world!";
2106 std::string header = ConstructDataHeader(strlen(kResponseBody));
2107 // Server sends data.
2108 ProcessPacket(ConstructServerDataPacket(3, !kFin, header + kResponseBody));
2109 EXPECT_EQ(static_cast<int64_t>(strlen(kResponseBody)), cb.WaitForResult());
2110
2111 base::RunLoop().RunUntilIdle();
2112
2113 EXPECT_EQ(1, delegate->on_data_read_count());
2114 EXPECT_EQ(0, delegate->on_data_sent_count());
2115 }
2116
TEST_P(BidirectionalStreamQuicImplTest,AsyncFinRead)2117 TEST_P(BidirectionalStreamQuicImplTest, AsyncFinRead) {
2118 const char kBody[] = "here is some data";
2119 SetRequest("POST", "/", DEFAULT_PRIORITY);
2120 size_t spdy_request_headers_frame_length;
2121 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
2122 AddWrite(ConstructInitialSettingsPacket());
2123 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE);
2124 AddWrite(ConstructRequestHeadersPacketInner(
2125 GetNthClientInitiatedBidirectionalStreamId(0), !kFin, DEFAULT_PRIORITY,
2126 &spdy_request_headers_frame_length));
2127 std::string header = ConstructDataHeader(strlen(kBody));
2128 AddWrite(ConstructClientDataPacket(kFin, header + kBody));
2129 AddWrite(ConstructClientAckPacket(3, 1));
2130
2131 Initialize();
2132
2133 BidirectionalStreamRequestInfo request;
2134 request.method = "POST";
2135 request.url = GURL("http://www.google.com/");
2136 request.end_stream_on_headers = false;
2137 request.priority = DEFAULT_PRIORITY;
2138
2139 auto read_buffer = base::MakeRefCounted<IOBufferWithSize>(kReadBufferSize);
2140 auto delegate =
2141 std::make_unique<TestDelegateBase>(read_buffer.get(), kReadBufferSize);
2142
2143 delegate->Start(&request, net_log_with_source(),
2144 session()->CreateHandle(destination_));
2145 ConfirmHandshake();
2146 delegate->WaitUntilNextCallback(kOnStreamReady);
2147
2148 // Send a Data packet with fin set.
2149 scoped_refptr<StringIOBuffer> buf1 =
2150 base::MakeRefCounted<StringIOBuffer>(kBody);
2151 delegate->SendData(buf1, buf1->size(), /*fin*/ true);
2152 delegate->WaitUntilNextCallback(kOnDataSent);
2153
2154 // Server acks the request.
2155 ProcessPacket(ConstructServerAckPacket(1, 1, 1, 1));
2156
2157 // Server sends the response headers.
2158 spdy::Http2HeaderBlock response_headers = ConstructResponseHeaders("200");
2159
2160 size_t spdy_response_headers_frame_length;
2161 ProcessPacket(
2162 ConstructResponseHeadersPacket(2, !kFin, std::move(response_headers),
2163 &spdy_response_headers_frame_length));
2164
2165 delegate->WaitUntilNextCallback(kOnHeadersReceived);
2166
2167 EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
2168
2169 // Read the body, which will complete asynchronously.
2170 TestCompletionCallback cb;
2171 int rv = delegate->ReadData(cb.callback());
2172 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
2173 const char kResponseBody[] = "Hello world!";
2174 std::string header2 = ConstructDataHeader(strlen(kResponseBody));
2175
2176 // Server sends data with the fin set, which should result in the stream
2177 // being closed and hence no RST_STREAM will be sent.
2178 ProcessPacket(ConstructServerDataPacket(3, kFin, header2 + kResponseBody));
2179 EXPECT_EQ(static_cast<int64_t>(strlen(kResponseBody)), cb.WaitForResult());
2180
2181 base::RunLoop().RunUntilIdle();
2182
2183 EXPECT_EQ(1, delegate->on_data_read_count());
2184 EXPECT_EQ(1, delegate->on_data_sent_count());
2185 }
2186
TEST_P(BidirectionalStreamQuicImplTest,DeleteStreamDuringOnTrailersReceived)2187 TEST_P(BidirectionalStreamQuicImplTest, DeleteStreamDuringOnTrailersReceived) {
2188 SetRequest("GET", "/", DEFAULT_PRIORITY);
2189 size_t spdy_request_headers_frame_length;
2190 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
2191 AddWrite(ConstructInitialSettingsPacket());
2192 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE);
2193 AddWrite(ConstructRequestHeadersPacket(kFin, DEFAULT_PRIORITY,
2194 &spdy_request_headers_frame_length));
2195 AddWrite(ConstructClientAckPacket(3, 1)); // Ack the data packet
2196 AddWrite(ConstructClientAckAndRstStreamPacket(4, 4));
2197
2198 Initialize();
2199
2200 BidirectionalStreamRequestInfo request;
2201 request.method = "GET";
2202 request.url = GURL("http://www.google.com/");
2203 request.end_stream_on_headers = true;
2204 request.priority = DEFAULT_PRIORITY;
2205
2206 auto read_buffer = base::MakeRefCounted<IOBufferWithSize>(kReadBufferSize);
2207 auto delegate = std::make_unique<DeleteStreamDelegate>(
2208 read_buffer.get(), kReadBufferSize,
2209 DeleteStreamDelegate::ON_TRAILERS_RECEIVED);
2210 delegate->Start(&request, net_log_with_source(),
2211 session()->CreateHandle(destination_));
2212 ConfirmHandshake();
2213 delegate->WaitUntilNextCallback(kOnStreamReady);
2214
2215 // Server acks the request.
2216 ProcessPacket(ConstructServerAckPacket(1, 1, 1, 1));
2217
2218 // Server sends the response headers.
2219 spdy::Http2HeaderBlock response_headers = ConstructResponseHeaders("200");
2220
2221 size_t spdy_response_headers_frame_length;
2222 ProcessPacket(
2223 ConstructResponseHeadersPacket(2, !kFin, std::move(response_headers),
2224 &spdy_response_headers_frame_length));
2225
2226 delegate->WaitUntilNextCallback(kOnHeadersReceived);
2227
2228 EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
2229
2230 TestCompletionCallback cb;
2231 int rv = delegate->ReadData(cb.callback());
2232 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
2233 const char kResponseBody[] = "Hello world!";
2234
2235 // Server sends data.
2236 std::string header = ConstructDataHeader(strlen(kResponseBody));
2237 ProcessPacket(ConstructServerDataPacket(3, !kFin, header + kResponseBody));
2238
2239 EXPECT_EQ(static_cast<int64_t>(strlen(kResponseBody)), cb.WaitForResult());
2240 EXPECT_EQ(std::string(kResponseBody), delegate->data_received());
2241
2242 size_t spdy_trailers_frame_length;
2243 spdy::Http2HeaderBlock trailers;
2244 trailers["foo"] = "bar";
2245 // Server sends trailers.
2246 ProcessPacket(ConstructResponseTrailersPacket(4, kFin, trailers.Clone(),
2247 &spdy_trailers_frame_length));
2248
2249 delegate->WaitUntilNextCallback(kOnTrailersReceived);
2250 EXPECT_EQ(trailers, delegate->trailers());
2251
2252 base::RunLoop().RunUntilIdle();
2253
2254 EXPECT_EQ(1, delegate->on_data_read_count());
2255 EXPECT_EQ(0, delegate->on_data_sent_count());
2256 }
2257
2258 // Tests that if QuicChromiumClientSession is closed after
2259 // BidirectionalStreamQuicImpl::OnStreamReady() but before
2260 // QuicChromiumClientSession::Handle::ReleaseStream() is called, there is no
2261 // crash. Regression test for crbug.com/754823.
TEST_P(BidirectionalStreamQuicImplTest,ReleaseStreamFails)2262 TEST_P(BidirectionalStreamQuicImplTest, ReleaseStreamFails) {
2263 SetRequest("GET", "/", DEFAULT_PRIORITY);
2264 Initialize();
2265
2266 ConfirmHandshake();
2267
2268 BidirectionalStreamRequestInfo request;
2269 request.method = "GET";
2270 request.url = GURL("http://www.google.com/");
2271 request.end_stream_on_headers = true;
2272 request.priority = DEFAULT_PRIORITY;
2273
2274 auto read_buffer = base::MakeRefCounted<IOBufferWithSize>(kReadBufferSize);
2275 auto delegate =
2276 std::make_unique<TestDelegateBase>(read_buffer.get(), kReadBufferSize);
2277 delegate->set_trailers_expected(true);
2278 // QuicChromiumClientSession::Handle::RequestStream() returns OK synchronously
2279 // because Initialize() has established a Session.
2280 delegate->Start(&request, net_log_with_source(),
2281 session()->CreateHandle(destination_));
2282 // Now closes the underlying session.
2283 session_->CloseSessionOnError(ERR_ABORTED, quic::QUIC_INTERNAL_ERROR,
2284 quic::ConnectionCloseBehavior::SILENT_CLOSE);
2285 delegate->WaitUntilNextCallback(kOnFailed);
2286
2287 EXPECT_THAT(delegate->error(), IsError(ERR_CONNECTION_CLOSED));
2288 }
2289
2290 } // namespace net::test
2291