1 // Copyright 2012 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/quic_http_stream.h"
6
7 #include <set>
8 #include <utility>
9
10 #include "base/auto_reset.h"
11 #include "base/functional/bind.h"
12 #include "base/metrics/histogram_functions.h"
13 #include "base/strings/string_split.h"
14 #include "base/task/single_thread_task_runner.h"
15 #include "net/base/features.h"
16 #include "net/base/ip_endpoint.h"
17 #include "net/base/load_flags.h"
18 #include "net/base/net_errors.h"
19 #include "net/http/http_response_headers.h"
20 #include "net/http/http_status_code.h"
21 #include "net/http/http_util.h"
22 #include "net/log/net_log.h"
23 #include "net/log/net_log_event_type.h"
24 #include "net/log/net_log_source.h"
25 #include "net/quic/quic_http_utils.h"
26 #include "net/spdy/spdy_http_utils.h"
27 #include "net/ssl/ssl_info.h"
28 #include "net/third_party/quiche/src/quiche/quic/core/http/spdy_utils.h"
29 #include "net/third_party/quiche/src/quiche/quic/core/quic_stream_sequencer.h"
30 #include "net/third_party/quiche/src/quiche/quic/core/quic_utils.h"
31 #include "net/third_party/quiche/src/quiche/spdy/core/spdy_frame_builder.h"
32 #include "net/third_party/quiche/src/quiche/spdy/core/spdy_framer.h"
33 #include "url/origin.h"
34 #include "url/scheme_host_port.h"
35
36 namespace net {
37
QuicHttpStream(std::unique_ptr<QuicChromiumClientSession::Handle> session,std::set<std::string> dns_aliases)38 QuicHttpStream::QuicHttpStream(
39 std::unique_ptr<QuicChromiumClientSession::Handle> session,
40 std::set<std::string> dns_aliases)
41 : MultiplexedHttpStream(std::move(session)),
42 dns_aliases_(std::move(dns_aliases)) {}
43
~QuicHttpStream()44 QuicHttpStream::~QuicHttpStream() {
45 CHECK(!in_loop_);
46 Close(false);
47 }
48
ConnectionInfoFromQuicVersion(quic::ParsedQuicVersion quic_version)49 HttpConnectionInfo QuicHttpStream::ConnectionInfoFromQuicVersion(
50 quic::ParsedQuicVersion quic_version) {
51 switch (quic_version.transport_version) {
52 case quic::QUIC_VERSION_UNSUPPORTED:
53 return HttpConnectionInfo::kQUIC_UNKNOWN_VERSION;
54 case quic::QUIC_VERSION_46:
55 return HttpConnectionInfo::kQUIC_46;
56 case quic::QUIC_VERSION_50:
57 return quic_version.UsesTls() ? HttpConnectionInfo::kQUIC_T050
58 : HttpConnectionInfo::kQUIC_Q050;
59 case quic::QUIC_VERSION_IETF_DRAFT_29:
60 DCHECK(quic_version.UsesTls());
61 return HttpConnectionInfo::kQUIC_DRAFT_29;
62 case quic::QUIC_VERSION_IETF_RFC_V1:
63 DCHECK(quic_version.UsesTls());
64 return HttpConnectionInfo::kQUIC_RFC_V1;
65 case quic::QUIC_VERSION_RESERVED_FOR_NEGOTIATION:
66 return HttpConnectionInfo::kQUIC_999;
67 case quic::QUIC_VERSION_IETF_RFC_V2:
68 DCHECK(quic_version.UsesTls());
69 return HttpConnectionInfo::kQUIC_2_DRAFT_8;
70 }
71 NOTREACHED();
72 return HttpConnectionInfo::kQUIC_UNKNOWN_VERSION;
73 }
74
RegisterRequest(const HttpRequestInfo * request_info)75 void QuicHttpStream::RegisterRequest(const HttpRequestInfo* request_info) {
76 DCHECK(request_info);
77 DCHECK(request_info->traffic_annotation.is_valid());
78 request_info_ = request_info;
79 }
80
InitializeStream(bool can_send_early,RequestPriority priority,const NetLogWithSource & stream_net_log,CompletionOnceCallback callback)81 int QuicHttpStream::InitializeStream(bool can_send_early,
82 RequestPriority priority,
83 const NetLogWithSource& stream_net_log,
84 CompletionOnceCallback callback) {
85 CHECK(callback_.is_null());
86 DCHECK(request_info_);
87 DCHECK(!stream_);
88
89 // HttpNetworkTransaction will retry any request that fails with
90 // ERR_QUIC_HANDSHAKE_FAILED. It will retry any request with
91 // ERR_CONNECTION_CLOSED so long as the connection has been used for other
92 // streams first and headers have not yet been received.
93 if (!quic_session()->IsConnected())
94 return GetResponseStatus();
95
96 stream_net_log.AddEventReferencingSource(
97 NetLogEventType::HTTP_STREAM_REQUEST_BOUND_TO_QUIC_SESSION,
98 quic_session()->net_log().source());
99 stream_net_log.AddEventWithIntParams(
100 NetLogEventType::QUIC_CONNECTION_MIGRATION_MODE,
101 "connection_migration_mode",
102 static_cast<int>(quic_session()->connection_migration_mode()));
103
104 stream_net_log_ = stream_net_log;
105 can_send_early_ = can_send_early;
106 request_time_ = base::Time::Now();
107 priority_ = priority;
108
109 SaveSSLInfo();
110
111 next_state_ = STATE_REQUEST_STREAM;
112 int rv = DoLoop(OK);
113 if (rv == ERR_IO_PENDING)
114 callback_ = std::move(callback);
115
116 return MapStreamError(rv);
117 }
118
SendRequest(const HttpRequestHeaders & request_headers,HttpResponseInfo * response,CompletionOnceCallback callback)119 int QuicHttpStream::SendRequest(const HttpRequestHeaders& request_headers,
120 HttpResponseInfo* response,
121 CompletionOnceCallback callback) {
122 CHECK(!request_body_stream_);
123 CHECK(!response_info_);
124 CHECK(callback_.is_null());
125 CHECK(!callback.is_null());
126 CHECK(response);
127
128 if (!stream_ || !quic_session()->IsConnected()) {
129 return GetResponseStatus();
130 }
131
132 // Store the serialized request headers.
133 CreateSpdyHeadersFromHttpRequest(*request_info_, priority_, request_headers,
134 &request_headers_);
135
136 // Store the request body.
137 request_body_stream_ = request_info_->upload_data_stream;
138 if (request_body_stream_) {
139 // TODO(rch): Can we be more precise about when to allocate
140 // raw_request_body_buf_. Removed the following check. DoReadRequestBody()
141 // was being called even if we didn't yet allocate raw_request_body_buf_.
142 // && (request_body_stream_->size() ||
143 // request_body_stream_->is_chunked()))
144 // Set the body buffer size to be the size of the body clamped
145 // into the range [10 * quic::kMaxOutgoingPacketSize, 256 *
146 // quic::kMaxOutgoingPacketSize]. With larger bodies, larger buffers reduce
147 // CPU usage.
148 raw_request_body_buf_ =
149 base::MakeRefCounted<IOBufferWithSize>(static_cast<size_t>(
150 std::max(10 * quic::kMaxOutgoingPacketSize,
151 std::min(request_body_stream_->size(),
152 256 * quic::kMaxOutgoingPacketSize))));
153 // The request body buffer is empty at first.
154 request_body_buf_ =
155 base::MakeRefCounted<DrainableIOBuffer>(raw_request_body_buf_, 0);
156 }
157
158 // Store the response info.
159 response_info_ = response;
160
161 // Put the peer's IP address and port into the response.
162 IPEndPoint address;
163 int rv = quic_session()->GetPeerAddress(&address);
164 if (rv != OK)
165 return rv;
166 response_info_->remote_endpoint = address;
167
168 next_state_ = STATE_SET_REQUEST_PRIORITY;
169 rv = DoLoop(OK);
170
171 if (rv == ERR_IO_PENDING)
172 callback_ = std::move(callback);
173
174 return rv > 0 ? OK : MapStreamError(rv);
175 }
176
ReadResponseHeaders(CompletionOnceCallback callback)177 int QuicHttpStream::ReadResponseHeaders(CompletionOnceCallback callback) {
178 CHECK(callback_.is_null());
179 CHECK(!callback.is_null());
180
181 int rv = stream_->ReadInitialHeaders(
182 &response_header_block_,
183 base::BindOnce(&QuicHttpStream::OnReadResponseHeadersComplete,
184 weak_factory_.GetWeakPtr()));
185
186 if (rv == ERR_IO_PENDING) {
187 // Still waiting for the response, return IO_PENDING.
188 CHECK(callback_.is_null());
189 callback_ = std::move(callback);
190 return ERR_IO_PENDING;
191 }
192
193 if (rv < 0)
194 return MapStreamError(rv);
195
196 // Check if we already have the response headers. If so, return synchronously.
197 if (response_headers_received_)
198 return OK;
199
200 headers_bytes_received_ += rv;
201 return ProcessResponseHeaders(response_header_block_);
202 }
203
ReadResponseBody(IOBuffer * buf,int buf_len,CompletionOnceCallback callback)204 int QuicHttpStream::ReadResponseBody(IOBuffer* buf,
205 int buf_len,
206 CompletionOnceCallback callback) {
207 CHECK(callback_.is_null());
208 CHECK(!callback.is_null());
209 CHECK(!user_buffer_.get());
210 CHECK_EQ(0, user_buffer_len_);
211
212 // Invalidate HttpRequestInfo pointer. This is to allow the stream to be
213 // shared across multiple transactions which might require this
214 // stream to outlive the request_info_'s owner.
215 // Only allowed when Read state machine starts. It is safe to reset it at
216 // this point since request_info_->upload_data_stream is also not needed
217 // anymore.
218 request_info_ = nullptr;
219
220 // If the stream is already closed, there is no body to read.
221 if (stream_->IsDoneReading())
222 return HandleReadComplete(OK);
223
224 int rv = stream_->ReadBody(buf, buf_len,
225 base::BindOnce(&QuicHttpStream::OnReadBodyComplete,
226 weak_factory_.GetWeakPtr()));
227 if (rv == ERR_IO_PENDING) {
228 callback_ = std::move(callback);
229 user_buffer_ = buf;
230 user_buffer_len_ = buf_len;
231 return ERR_IO_PENDING;
232 }
233
234 if (rv < 0)
235 return MapStreamError(rv);
236
237 return HandleReadComplete(rv);
238 }
239
Close(bool)240 void QuicHttpStream::Close(bool /*not_reusable*/) {
241 session_error_ = ERR_ABORTED;
242 SaveResponseStatus();
243 // Note: the not_reusable flag has no meaning for QUIC streams.
244 if (stream_)
245 stream_->Reset(quic::QUIC_STREAM_CANCELLED);
246 ResetStream();
247 }
248
IsResponseBodyComplete() const249 bool QuicHttpStream::IsResponseBodyComplete() const {
250 return next_state_ == STATE_OPEN && stream_->IsDoneReading();
251 }
252
IsConnectionReused() const253 bool QuicHttpStream::IsConnectionReused() const {
254 // TODO(rch): do something smarter here.
255 return stream_ && stream_->id() > 1;
256 }
257
GetTotalReceivedBytes() const258 int64_t QuicHttpStream::GetTotalReceivedBytes() const {
259 if (stream_) {
260 DCHECK_LE(stream_->NumBytesConsumed(), stream_->stream_bytes_read());
261 // Only count the uniquely received bytes.
262 return stream_->NumBytesConsumed();
263 }
264 return closed_stream_received_bytes_;
265 }
266
GetTotalSentBytes() const267 int64_t QuicHttpStream::GetTotalSentBytes() const {
268 if (stream_) {
269 return stream_->stream_bytes_written();
270 }
271 return closed_stream_sent_bytes_;
272 }
273
GetLoadTimingInfo(LoadTimingInfo * load_timing_info) const274 bool QuicHttpStream::GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const {
275 bool is_first_stream = closed_is_first_stream_;
276 if (stream_) {
277 is_first_stream = stream_->IsFirstStream();
278 load_timing_info->first_early_hints_time =
279 stream_->first_early_hints_time();
280 load_timing_info->receive_non_informational_headers_start =
281 stream_->headers_received_start_time();
282 load_timing_info->receive_headers_start =
283 load_timing_info->first_early_hints_time.is_null()
284 ? load_timing_info->receive_non_informational_headers_start
285 : load_timing_info->first_early_hints_time;
286 }
287
288 if (is_first_stream) {
289 load_timing_info->socket_reused = false;
290 load_timing_info->connect_timing = connect_timing_;
291 } else {
292 load_timing_info->socket_reused = true;
293 }
294 return true;
295 }
296
GetAlternativeService(AlternativeService * alternative_service) const297 bool QuicHttpStream::GetAlternativeService(
298 AlternativeService* alternative_service) const {
299 alternative_service->protocol = kProtoQUIC;
300 const url::SchemeHostPort& destination = quic_session()->destination();
301 alternative_service->host = destination.host();
302 alternative_service->port = destination.port();
303 return true;
304 }
305
PopulateNetErrorDetails(NetErrorDetails * details)306 void QuicHttpStream::PopulateNetErrorDetails(NetErrorDetails* details) {
307 details->connection_info =
308 ConnectionInfoFromQuicVersion(quic_session()->GetQuicVersion());
309 quic_session()->PopulateNetErrorDetails(details);
310 if (quic_session()->OneRttKeysAvailable() && stream_ &&
311 stream_->connection_error() != quic::QUIC_NO_ERROR)
312 details->quic_connection_error = stream_->connection_error();
313 }
314
SetPriority(RequestPriority priority)315 void QuicHttpStream::SetPriority(RequestPriority priority) {
316 priority_ = priority;
317 }
318
OnReadResponseHeadersComplete(int rv)319 void QuicHttpStream::OnReadResponseHeadersComplete(int rv) {
320 DCHECK(callback_);
321 DCHECK(!response_headers_received_);
322 if (rv > 0) {
323 headers_bytes_received_ += rv;
324 rv = ProcessResponseHeaders(response_header_block_);
325 }
326 if (rv != ERR_IO_PENDING && !callback_.is_null()) {
327 DoCallback(rv);
328 }
329 }
330
GetDnsAliases() const331 const std::set<std::string>& QuicHttpStream::GetDnsAliases() const {
332 return dns_aliases_;
333 }
334
GetAcceptChViaAlps() const335 base::StringPiece QuicHttpStream::GetAcceptChViaAlps() const {
336 if (!request_info_) {
337 return {};
338 }
339
340 return session()->GetAcceptChViaAlps(url::SchemeHostPort(request_info_->url));
341 }
342
GetQuicErrorCode() const343 absl::optional<quic::QuicErrorCode> QuicHttpStream::GetQuicErrorCode() const {
344 if (stream_) {
345 return stream_->connection_error();
346 }
347 return connection_error_;
348 }
349
350 absl::optional<quic::QuicRstStreamErrorCode>
GetQuicRstStreamErrorCode() const351 QuicHttpStream::GetQuicRstStreamErrorCode() const {
352 if (stream_) {
353 return stream_->stream_error();
354 }
355 return stream_error_;
356 }
357
ReadTrailingHeaders()358 void QuicHttpStream::ReadTrailingHeaders() {
359 int rv = stream_->ReadTrailingHeaders(
360 &trailing_header_block_,
361 base::BindOnce(&QuicHttpStream::OnReadTrailingHeadersComplete,
362 weak_factory_.GetWeakPtr()));
363
364 if (rv != ERR_IO_PENDING)
365 OnReadTrailingHeadersComplete(rv);
366 }
367
OnReadTrailingHeadersComplete(int rv)368 void QuicHttpStream::OnReadTrailingHeadersComplete(int rv) {
369 DCHECK(response_headers_received_);
370 if (rv > 0)
371 headers_bytes_received_ += rv;
372
373 // QuicHttpStream ignores trailers.
374 if (stream_->IsDoneReading()) {
375 // Close the read side. If the write side has been closed, this will
376 // invoke QuicHttpStream::OnClose to reset the stream.
377 stream_->OnFinRead();
378 SetResponseStatus(OK);
379 }
380 }
381
OnIOComplete(int rv)382 void QuicHttpStream::OnIOComplete(int rv) {
383 rv = DoLoop(rv);
384
385 if (rv != ERR_IO_PENDING && !callback_.is_null()) {
386 DoCallback(rv);
387 }
388 }
389
DoCallback(int rv)390 void QuicHttpStream::DoCallback(int rv) {
391 CHECK_NE(rv, ERR_IO_PENDING);
392 CHECK(!callback_.is_null());
393 CHECK(!in_loop_);
394
395 // The client callback can do anything, including destroying this class,
396 // so any pending callback must be issued after everything else is done.
397 std::move(callback_).Run(MapStreamError(rv));
398 }
399
DoLoop(int rv)400 int QuicHttpStream::DoLoop(int rv) {
401 CHECK(!in_loop_);
402 base::AutoReset<bool> auto_reset_in_loop(&in_loop_, true);
403 std::unique_ptr<quic::QuicConnection::ScopedPacketFlusher> packet_flusher =
404 quic_session()->CreatePacketBundler();
405 do {
406 State state = next_state_;
407 next_state_ = STATE_NONE;
408 switch (state) {
409 case STATE_REQUEST_STREAM:
410 CHECK_EQ(OK, rv);
411 rv = DoRequestStream();
412 break;
413 case STATE_REQUEST_STREAM_COMPLETE:
414 rv = DoRequestStreamComplete(rv);
415 break;
416 case STATE_SET_REQUEST_PRIORITY:
417 CHECK_EQ(OK, rv);
418 rv = DoSetRequestPriority();
419 break;
420 case STATE_SEND_HEADERS:
421 CHECK_EQ(OK, rv);
422 rv = DoSendHeaders();
423 break;
424 case STATE_SEND_HEADERS_COMPLETE:
425 rv = DoSendHeadersComplete(rv);
426 break;
427 case STATE_READ_REQUEST_BODY:
428 CHECK_EQ(OK, rv);
429 rv = DoReadRequestBody();
430 break;
431 case STATE_READ_REQUEST_BODY_COMPLETE:
432 rv = DoReadRequestBodyComplete(rv);
433 break;
434 case STATE_SEND_BODY:
435 CHECK_EQ(OK, rv);
436 rv = DoSendBody();
437 break;
438 case STATE_SEND_BODY_COMPLETE:
439 rv = DoSendBodyComplete(rv);
440 break;
441 case STATE_OPEN:
442 CHECK_EQ(OK, rv);
443 break;
444 default:
445 NOTREACHED() << "next_state_: " << next_state_;
446 break;
447 }
448 } while (next_state_ != STATE_NONE && next_state_ != STATE_OPEN &&
449 rv != ERR_IO_PENDING);
450
451 return rv;
452 }
453
DoRequestStream()454 int QuicHttpStream::DoRequestStream() {
455 next_state_ = STATE_REQUEST_STREAM_COMPLETE;
456
457 return quic_session()->RequestStream(
458 !can_send_early_,
459 base::BindOnce(&QuicHttpStream::OnIOComplete, weak_factory_.GetWeakPtr()),
460 NetworkTrafficAnnotationTag(request_info_->traffic_annotation));
461 }
462
DoRequestStreamComplete(int rv)463 int QuicHttpStream::DoRequestStreamComplete(int rv) {
464 DCHECK(rv == OK || !stream_);
465 if (rv != OK) {
466 session_error_ = rv;
467 return GetResponseStatus();
468 }
469
470 stream_ = quic_session()->ReleaseStream();
471 DCHECK(stream_);
472 if (!stream_->IsOpen()) {
473 session_error_ = ERR_CONNECTION_CLOSED;
474 return GetResponseStatus();
475 }
476
477 if (request_info_->load_flags &
478 LOAD_DISABLE_CONNECTION_MIGRATION_TO_CELLULAR) {
479 stream_->DisableConnectionMigrationToCellularNetwork();
480 }
481
482 DCHECK(response_info_ == nullptr);
483
484 return OK;
485 }
486
DoSetRequestPriority()487 int QuicHttpStream::DoSetRequestPriority() {
488 // Set priority according to request
489 DCHECK(stream_);
490 DCHECK(response_info_);
491 DCHECK(request_info_);
492
493 uint8_t urgency = ConvertRequestPriorityToQuicPriority(priority_);
494 bool incremental = request_info_->priority_incremental;
495 stream_->SetPriority(
496 quic::QuicStreamPriority(quic::HttpStreamPriority{urgency, incremental}));
497 next_state_ = STATE_SEND_HEADERS;
498 return OK;
499 }
500
DoSendHeaders()501 int QuicHttpStream::DoSendHeaders() {
502 uint8_t urgency = ConvertRequestPriorityToQuicPriority(priority_);
503 bool incremental = request_info_->priority_incremental;
504 quic::QuicStreamPriority priority(
505 quic::HttpStreamPriority{urgency, incremental});
506 // Log the actual request with the URL Request's net log.
507 stream_net_log_.AddEvent(
508 NetLogEventType::HTTP_TRANSACTION_QUIC_SEND_REQUEST_HEADERS,
509 [&](NetLogCaptureMode capture_mode) {
510 return QuicRequestNetLogParams(stream_->id(), &request_headers_,
511 priority, capture_mode);
512 });
513 DispatchRequestHeadersCallback(request_headers_);
514 bool has_upload_data = request_body_stream_ != nullptr;
515
516 next_state_ = STATE_SEND_HEADERS_COMPLETE;
517 int rv = stream_->WriteHeaders(std::move(request_headers_), !has_upload_data,
518 nullptr);
519 if (rv > 0)
520 headers_bytes_sent_ += rv;
521
522 request_headers_ = spdy::Http2HeaderBlock();
523 return rv;
524 }
525
DoSendHeadersComplete(int rv)526 int QuicHttpStream::DoSendHeadersComplete(int rv) {
527 if (rv < 0)
528 return rv;
529
530 next_state_ = request_body_stream_ ? STATE_READ_REQUEST_BODY : STATE_OPEN;
531
532 return OK;
533 }
534
DoReadRequestBody()535 int QuicHttpStream::DoReadRequestBody() {
536 next_state_ = STATE_READ_REQUEST_BODY_COMPLETE;
537 return request_body_stream_->Read(
538 raw_request_body_buf_.get(), raw_request_body_buf_->size(),
539 base::BindOnce(&QuicHttpStream::OnIOComplete,
540 weak_factory_.GetWeakPtr()));
541 }
542
DoReadRequestBodyComplete(int rv)543 int QuicHttpStream::DoReadRequestBodyComplete(int rv) {
544 // |rv| is the result of read from the request body from the last call to
545 // DoSendBody().
546 if (rv < 0) {
547 stream_->Reset(quic::QUIC_ERROR_PROCESSING_STREAM);
548 ResetStream();
549 return rv;
550 }
551
552 request_body_buf_ =
553 base::MakeRefCounted<DrainableIOBuffer>(raw_request_body_buf_, rv);
554 if (rv == 0) { // Reached the end.
555 DCHECK(request_body_stream_->IsEOF());
556 }
557
558 next_state_ = STATE_SEND_BODY;
559 return OK;
560 }
561
DoSendBody()562 int QuicHttpStream::DoSendBody() {
563 CHECK(request_body_stream_);
564 CHECK(request_body_buf_.get());
565 const bool eof = request_body_stream_->IsEOF();
566 int len = request_body_buf_->BytesRemaining();
567 if (len > 0 || eof) {
568 next_state_ = STATE_SEND_BODY_COMPLETE;
569 base::StringPiece data(request_body_buf_->data(), len);
570 return stream_->WriteStreamData(
571 data, eof,
572 base::BindOnce(&QuicHttpStream::OnIOComplete,
573 weak_factory_.GetWeakPtr()));
574 }
575
576 next_state_ = STATE_OPEN;
577 return OK;
578 }
579
DoSendBodyComplete(int rv)580 int QuicHttpStream::DoSendBodyComplete(int rv) {
581 if (rv < 0)
582 return rv;
583
584 request_body_buf_->DidConsume(request_body_buf_->BytesRemaining());
585
586 if (!request_body_stream_->IsEOF()) {
587 next_state_ = STATE_READ_REQUEST_BODY;
588 return OK;
589 }
590
591 next_state_ = STATE_OPEN;
592 return OK;
593 }
594
ProcessResponseHeaders(const spdy::Http2HeaderBlock & headers)595 int QuicHttpStream::ProcessResponseHeaders(
596 const spdy::Http2HeaderBlock& headers) {
597 const int rv = SpdyHeadersToHttpResponse(headers, response_info_);
598 base::UmaHistogramBoolean("Net.QuicHttpStream.ProcessResponseHeaderSuccess",
599 rv == OK);
600 if (rv != OK) {
601 DLOG(WARNING) << "Invalid headers";
602 return ERR_QUIC_PROTOCOL_ERROR;
603 }
604
605 if (response_info_->headers->response_code() == HTTP_EARLY_HINTS) {
606 DCHECK(!response_headers_received_);
607 headers_bytes_received_ = 0;
608 return OK;
609 }
610
611 response_info_->connection_info =
612 ConnectionInfoFromQuicVersion(quic_session()->GetQuicVersion());
613 response_info_->was_alpn_negotiated = true;
614 response_info_->alpn_negotiated_protocol =
615 HttpConnectionInfoToString(response_info_->connection_info);
616 response_info_->response_time = base::Time::Now();
617 response_info_->request_time = request_time_;
618 response_headers_received_ = true;
619
620 // Populate |connect_timing_| when response headers are received. This should
621 // take care of 0-RTT where request is sent before handshake is confirmed.
622 connect_timing_ = quic_session()->GetConnectTiming();
623
624 base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
625 FROM_HERE, base::BindOnce(&QuicHttpStream::ReadTrailingHeaders,
626 weak_factory_.GetWeakPtr()));
627
628 if (stream_->IsDoneReading()) {
629 session_error_ = OK;
630 SaveResponseStatus();
631 stream_->OnFinRead();
632 }
633
634 return OK;
635 }
636
OnReadBodyComplete(int rv)637 void QuicHttpStream::OnReadBodyComplete(int rv) {
638 CHECK(callback_);
639 user_buffer_ = nullptr;
640 user_buffer_len_ = 0;
641 rv = HandleReadComplete(rv);
642 DoCallback(rv);
643 }
644
HandleReadComplete(int rv)645 int QuicHttpStream::HandleReadComplete(int rv) {
646 if (stream_->IsDoneReading()) {
647 stream_->OnFinRead();
648 SetResponseStatus(OK);
649 ResetStream();
650 }
651 return rv;
652 }
653
ResetStream()654 void QuicHttpStream::ResetStream() {
655 // If |request_body_stream_| is non-NULL, Reset it, to abort any in progress
656 // read.
657 if (request_body_stream_)
658 request_body_stream_->Reset();
659
660 if (!stream_)
661 return;
662
663 DCHECK_LE(stream_->NumBytesConsumed(), stream_->stream_bytes_read());
664 // Only count the uniquely received bytes.
665 closed_stream_received_bytes_ = stream_->NumBytesConsumed();
666 closed_stream_sent_bytes_ = stream_->stream_bytes_written();
667 closed_is_first_stream_ = stream_->IsFirstStream();
668 connection_error_ = stream_->connection_error();
669 stream_error_ = stream_->stream_error();
670 }
671
MapStreamError(int rv)672 int QuicHttpStream::MapStreamError(int rv) {
673 if (rv == ERR_QUIC_PROTOCOL_ERROR && !quic_session()->OneRttKeysAvailable()) {
674 return ERR_QUIC_HANDSHAKE_FAILED;
675 }
676 return rv;
677 }
678
GetResponseStatus()679 int QuicHttpStream::GetResponseStatus() {
680 SaveResponseStatus();
681 return response_status_;
682 }
683
SaveResponseStatus()684 void QuicHttpStream::SaveResponseStatus() {
685 if (!has_response_status_)
686 SetResponseStatus(ComputeResponseStatus());
687 }
688
SetResponseStatus(int response_status)689 void QuicHttpStream::SetResponseStatus(int response_status) {
690 has_response_status_ = true;
691 response_status_ = response_status;
692 }
693
ComputeResponseStatus() const694 int QuicHttpStream::ComputeResponseStatus() const {
695 DCHECK(!has_response_status_);
696
697 // If the handshake has failed this will be handled by the QuicStreamFactory
698 // and HttpStreamFactory to mark QUIC as broken if TCP is actually working.
699 if (!quic_session()->OneRttKeysAvailable())
700 return ERR_QUIC_HANDSHAKE_FAILED;
701
702 // If the session was aborted by a higher layer, simply use that error code.
703 if (session_error_ != ERR_UNEXPECTED)
704 return session_error_;
705
706 // If |response_info_| is null then the request has not been sent, so
707 // return ERR_CONNECTION_CLOSED to permit HttpNetworkTransaction to
708 // retry the request.
709 if (!response_info_)
710 return ERR_CONNECTION_CLOSED;
711
712 base::UmaHistogramEnumeration("Net.QuicHttpStream.ResponseStatus",
713 stream_->stream_error(),
714 quic::QUIC_STREAM_LAST_ERROR);
715
716 return ERR_QUIC_PROTOCOL_ERROR;
717 }
718
SetRequestIdempotency(Idempotency idempotency)719 void QuicHttpStream::SetRequestIdempotency(Idempotency idempotency) {
720 if (stream_ == nullptr) {
721 return;
722 }
723 stream_->SetRequestIdempotency(idempotency);
724 }
725
726 } // namespace net
727