1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef QUICHE_QUIC_CORE_HTTP_QUIC_SPDY_CLIENT_STREAM_H_ 6 #define QUICHE_QUIC_CORE_HTTP_QUIC_SPDY_CLIENT_STREAM_H_ 7 8 #include <cstddef> 9 #include <list> 10 #include <string> 11 12 #include "absl/strings/string_view.h" 13 #include "quiche/quic/core/http/quic_spdy_stream.h" 14 #include "quiche/quic/core/quic_packets.h" 15 #include "quiche/spdy/core/http2_header_block.h" 16 #include "quiche/spdy/core/spdy_framer.h" 17 18 namespace quic { 19 20 class QuicSpdyClientSession; 21 22 // All this does right now is send an SPDY request, and aggregate the 23 // SPDY response. 24 class QUICHE_EXPORT QuicSpdyClientStream : public QuicSpdyStream { 25 public: 26 QuicSpdyClientStream(QuicStreamId id, QuicSpdyClientSession* session, 27 StreamType type); 28 QuicSpdyClientStream(PendingStream* pending, 29 QuicSpdyClientSession* spdy_session); 30 QuicSpdyClientStream(const QuicSpdyClientStream&) = delete; 31 QuicSpdyClientStream& operator=(const QuicSpdyClientStream&) = delete; 32 ~QuicSpdyClientStream() override; 33 34 // Override the base class to parse and store headers. 35 void OnInitialHeadersComplete(bool fin, size_t frame_len, 36 const QuicHeaderList& header_list) override; 37 38 // Override the base class to parse and store trailers. 39 void OnTrailingHeadersComplete(bool fin, size_t frame_len, 40 const QuicHeaderList& header_list) override; 41 42 // QuicStream implementation called by the session when there's data for us. 43 void OnBodyAvailable() override; 44 45 void OnFinRead() override; 46 47 // Serializes the headers and body, sends it to the server, and 48 // returns the number of bytes sent. 49 size_t SendRequest(spdy::Http2HeaderBlock headers, absl::string_view body, 50 bool fin); 51 52 // Returns the response data. data()53 absl::string_view data() const { return data_; } 54 55 // Returns whatever headers have been received for this stream. response_headers()56 const spdy::Http2HeaderBlock& response_headers() { return response_headers_; } 57 preliminary_headers()58 const std::list<spdy::Http2HeaderBlock>& preliminary_headers() { 59 return preliminary_headers_; 60 } 61 header_bytes_read()62 size_t header_bytes_read() const { return header_bytes_read_; } 63 header_bytes_written()64 size_t header_bytes_written() const { return header_bytes_written_; } 65 response_code()66 int response_code() const { return response_code_; } 67 time_to_response_headers_received()68 QuicTime::Delta time_to_response_headers_received() const { 69 return time_to_response_headers_received_; 70 } 71 time_to_response_complete()72 QuicTime::Delta time_to_response_complete() const { 73 return time_to_response_complete_; 74 } 75 76 // While the server's SetPriority shouldn't be called externally, the creator 77 // of client-side streams should be able to set the priority. 78 using QuicSpdyStream::SetPriority; 79 80 protected: 81 bool ValidateReceivedHeaders(const QuicHeaderList& header_list) override; 82 83 // Called by OnInitialHeadersComplete to set response_header_. Returns false 84 // on error. 85 virtual bool CopyAndValidateHeaders(const QuicHeaderList& header_list, 86 int64_t& content_length, 87 spdy::Http2HeaderBlock& headers); 88 89 // Called by OnInitialHeadersComplete to set response_code_ based on 90 // response_header_. Returns false on error. 91 virtual bool ParseAndValidateStatusCode(); 92 93 private: 94 // The parsed headers received from the server. 95 spdy::Http2HeaderBlock response_headers_; 96 97 // The parsed content-length, or -1 if none is specified. 98 int64_t content_length_; 99 int response_code_; 100 std::string data_; 101 size_t header_bytes_read_; 102 size_t header_bytes_written_; 103 104 QuicSpdyClientSession* session_; 105 106 // These preliminary headers are used for interim response headers that may 107 // arrive before the final response headers. 108 std::list<spdy::Http2HeaderBlock> preliminary_headers_; 109 110 QuicTime::Delta time_to_response_headers_received_ = 111 QuicTime::Delta::Infinite(); 112 QuicTime::Delta time_to_response_complete_ = QuicTime::Delta::Infinite(); 113 }; 114 115 } // namespace quic 116 117 #endif // QUICHE_QUIC_CORE_HTTP_QUIC_SPDY_CLIENT_STREAM_H_ 118