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