Make HttpEncoder methods static. This class stores no state, no need to ever instantiate it. gfe-relnote: n/a, no functional change. PiperOrigin-RevId: 277333157 Change-Id: I9ea319aa186b975325a70a321a50259eaec47093
diff --git a/quic/core/http/http_decoder_test.cc b/quic/core/http/http_decoder_test.cc index 42b4dd2..965cdfd 100644 --- a/quic/core/http/http_decoder_test.cc +++ b/quic/core/http/http_decoder_test.cc
@@ -615,10 +615,9 @@ InSequence s; // A large input that will occupy more than 1 byte in the length field. std::string input(2048, 'x'); - HttpEncoder encoder; std::unique_ptr<char[]> buffer; QuicByteCount header_length = - encoder.SerializeDataFrameHeader(input.length(), &buffer); + HttpEncoder::SerializeDataFrameHeader(input.length(), &buffer); std::string header = std::string(buffer.get(), header_length); // Partially send only 1 byte of the header to process. EXPECT_EQ(1u, decoder_.ProcessInput(header.data(), 1)); @@ -1034,11 +1033,10 @@ } TEST_F(HttpDecoderTest, LargeStreamIdInGoAway) { - HttpEncoder encoder; GoAwayFrame frame; frame.stream_id = 1 << 30; std::unique_ptr<char[]> buffer; - uint64_t length = encoder.SerializeGoAwayFrame(frame, &buffer); + uint64_t length = HttpEncoder::SerializeGoAwayFrame(frame, &buffer); EXPECT_CALL(visitor_, OnGoAwayFrame(frame)); EXPECT_GT(length, 0u); EXPECT_EQ(length, decoder_.ProcessInput(buffer.get(), length));
diff --git a/quic/core/http/http_encoder.cc b/quic/core/http/http_encoder.cc index b97f7f7..6bb25cf 100644 --- a/quic/core/http/http_encoder.cc +++ b/quic/core/http/http_encoder.cc
@@ -40,12 +40,45 @@ } } +bool WriteFrameHeader(QuicByteCount length, + HttpFrameType type, + QuicDataWriter* writer) { + return writer->WriteVarInt62(static_cast<uint64_t>(type)) && + writer->WriteVarInt62(length); +} + +QuicByteCount GetTotalLength(QuicByteCount payload_length, HttpFrameType type) { + return QuicDataWriter::GetVarInt62Len(payload_length) + + QuicDataWriter::GetVarInt62Len(static_cast<uint64_t>(type)) + + payload_length; +} + +// Write prioritized element id and element dependency id if needed. +bool MaybeWriteIds(const PriorityFrame& priority, QuicDataWriter* writer) { + if (priority.prioritized_type != ROOT_OF_TREE) { + if (!writer->WriteVarInt62(priority.prioritized_element_id)) { + return false; + } + } else { + DCHECK_EQ(0u, priority.prioritized_element_id) + << "Prioritized element id should be 0 when prioritized type is " + "ROOT_OF_TREE"; + } + if (priority.dependency_type != ROOT_OF_TREE) { + if (!writer->WriteVarInt62(priority.element_dependency_id)) { + return false; + } + } else { + DCHECK_EQ(0u, priority.element_dependency_id) + << "Element dependency id should be 0 when dependency type is " + "ROOT_OF_TREE"; + } + return true; +} + } // namespace -HttpEncoder::HttpEncoder() {} - -HttpEncoder::~HttpEncoder() {} - +// static QuicByteCount HttpEncoder::SerializeDataFrameHeader( QuicByteCount payload_length, std::unique_ptr<char[]>* output) { @@ -65,6 +98,7 @@ return 0; } +// static QuicByteCount HttpEncoder::SerializeHeadersFrameHeader( QuicByteCount payload_length, std::unique_ptr<char[]>* output) { @@ -86,6 +120,7 @@ return 0; } +// static QuicByteCount HttpEncoder::SerializePriorityFrame( const PriorityFrame& priority, std::unique_ptr<char[]>* output) { @@ -127,6 +162,7 @@ return 0; } +// static QuicByteCount HttpEncoder::SerializeCancelPushFrame( const CancelPushFrame& cancel_push, std::unique_ptr<char[]>* output) { @@ -147,6 +183,7 @@ return 0; } +// static QuicByteCount HttpEncoder::SerializeSettingsFrame( const SettingsFrame& settings, std::unique_ptr<char[]>* output) { @@ -180,6 +217,7 @@ return total_length; } +// static QuicByteCount HttpEncoder::SerializePushPromiseFrameWithOnlyPushId( const PushPromiseFrame& push_promise, std::unique_ptr<char[]>* output) { @@ -205,6 +243,7 @@ return 0; } +// static QuicByteCount HttpEncoder::SerializeGoAwayFrame( const GoAwayFrame& goaway, std::unique_ptr<char[]>* output) { @@ -225,6 +264,7 @@ return 0; } +// static QuicByteCount HttpEncoder::SerializeMaxPushIdFrame( const MaxPushIdFrame& max_push_id, std::unique_ptr<char[]>* output) { @@ -245,6 +285,7 @@ return 0; } +// static QuicByteCount HttpEncoder::SerializeDuplicatePushFrame( const DuplicatePushFrame& duplicate_push, std::unique_ptr<char[]>* output) { @@ -266,41 +307,4 @@ return 0; } -bool HttpEncoder::WriteFrameHeader(QuicByteCount length, - HttpFrameType type, - QuicDataWriter* writer) { - return writer->WriteVarInt62(static_cast<uint64_t>(type)) && - writer->WriteVarInt62(length); -} - -QuicByteCount HttpEncoder::GetTotalLength(QuicByteCount payload_length, - HttpFrameType type) { - return QuicDataWriter::GetVarInt62Len(payload_length) + - QuicDataWriter::GetVarInt62Len(static_cast<uint64_t>(type)) + - payload_length; -} - -bool HttpEncoder::MaybeWriteIds(const PriorityFrame& priority, - QuicDataWriter* writer) { - if (priority.prioritized_type != ROOT_OF_TREE) { - if (!writer->WriteVarInt62(priority.prioritized_element_id)) { - return false; - } - } else { - DCHECK_EQ(0u, priority.prioritized_element_id) - << "Prioritized element id should be 0 when prioritized type is " - "ROOT_OF_TREE"; - } - if (priority.dependency_type != ROOT_OF_TREE) { - if (!writer->WriteVarInt62(priority.element_dependency_id)) { - return false; - } - } else { - DCHECK_EQ(0u, priority.element_dependency_id) - << "Element dependency id should be 0 when dependency type is " - "ROOT_OF_TREE"; - } - return true; -} - } // namespace quic
diff --git a/quic/core/http/http_encoder.h b/quic/core/http/http_encoder.h index 12c5bab..4420fc6 100644 --- a/quic/core/http/http_encoder.h +++ b/quic/core/http/http_encoder.h
@@ -17,68 +17,59 @@ // session. class QUIC_EXPORT_PRIVATE HttpEncoder { public: - HttpEncoder(); - - ~HttpEncoder(); + HttpEncoder() = delete; // Serializes a DATA frame header into a new buffer stored in |output|. // Returns the length of the buffer on success, or 0 otherwise. - QuicByteCount SerializeDataFrameHeader(QuicByteCount payload_length, - std::unique_ptr<char[]>* output); + static QuicByteCount SerializeDataFrameHeader( + QuicByteCount payload_length, + std::unique_ptr<char[]>* output); // Serializes a HEADERS frame header into a new buffer stored in |output|. // Returns the length of the buffer on success, or 0 otherwise. - QuicByteCount SerializeHeadersFrameHeader(QuicByteCount payload_length, - std::unique_ptr<char[]>* output); + static QuicByteCount SerializeHeadersFrameHeader( + QuicByteCount payload_length, + std::unique_ptr<char[]>* output); // Serializes a PRIORITY frame into a new buffer stored in |output|. // Returns the length of the buffer on success, or 0 otherwise. - QuicByteCount SerializePriorityFrame(const PriorityFrame& priority, - std::unique_ptr<char[]>* output); + static QuicByteCount SerializePriorityFrame(const PriorityFrame& priority, + std::unique_ptr<char[]>* output); // Serializes a CANCEL_PUSH frame into a new buffer stored in |output|. // Returns the length of the buffer on success, or 0 otherwise. - QuicByteCount SerializeCancelPushFrame(const CancelPushFrame& cancel_push, - std::unique_ptr<char[]>* output); + static QuicByteCount SerializeCancelPushFrame( + const CancelPushFrame& cancel_push, + std::unique_ptr<char[]>* output); // Serializes a SETTINGS frame into a new buffer stored in |output|. // Returns the length of the buffer on success, or 0 otherwise. - QuicByteCount SerializeSettingsFrame(const SettingsFrame& settings, - std::unique_ptr<char[]>* output); + static QuicByteCount SerializeSettingsFrame(const SettingsFrame& settings, + std::unique_ptr<char[]>* output); // Serializes the header and push_id of a PUSH_PROMISE frame into a new buffer // stored in |output|. Returns the length of the buffer on success, or 0 // otherwise. - QuicByteCount SerializePushPromiseFrameWithOnlyPushId( + static QuicByteCount SerializePushPromiseFrameWithOnlyPushId( const PushPromiseFrame& push_promise, std::unique_ptr<char[]>* output); // Serializes a GOAWAY frame into a new buffer stored in |output|. // Returns the length of the buffer on success, or 0 otherwise. - QuicByteCount SerializeGoAwayFrame(const GoAwayFrame& goaway, - std::unique_ptr<char[]>* output); + static QuicByteCount SerializeGoAwayFrame(const GoAwayFrame& goaway, + std::unique_ptr<char[]>* output); // Serializes a MAX_PUSH frame into a new buffer stored in |output|. // Returns the length of the buffer on success, or 0 otherwise. - QuicByteCount SerializeMaxPushIdFrame(const MaxPushIdFrame& max_push_id, - std::unique_ptr<char[]>* output); + static QuicByteCount SerializeMaxPushIdFrame( + const MaxPushIdFrame& max_push_id, + std::unique_ptr<char[]>* output); // Serialize a DUPLICATE_PUSH frame into a new buffer stored in |output|. // Returns the length of the buffer on success, or 0 otherwise. - QuicByteCount SerializeDuplicatePushFrame( + static QuicByteCount SerializeDuplicatePushFrame( const DuplicatePushFrame& duplicate_push, std::unique_ptr<char[]>* output); - - private: - bool WriteFrameHeader(QuicByteCount length, - HttpFrameType type, - QuicDataWriter* writer); - - QuicByteCount GetTotalLength(QuicByteCount payload_length, - HttpFrameType type); - - // Write prioritized element id and element dependency id if needed. - bool MaybeWriteIds(const PriorityFrame& priority, QuicDataWriter* writer); }; } // namespace quic
diff --git a/quic/core/http/http_encoder_test.cc b/quic/core/http/http_encoder_test.cc index 43ae7cd..2df89bd 100644 --- a/quic/core/http/http_encoder_test.cc +++ b/quic/core/http/http_encoder_test.cc
@@ -11,16 +11,10 @@ namespace quic { namespace test { -class HttpEncoderTest : public QuicTest { - public: - HttpEncoderTest() {} - HttpEncoder encoder_; -}; - -TEST_F(HttpEncoderTest, SerializeDataFrameHeader) { +TEST(HttpEncoderTest, SerializeDataFrameHeader) { std::unique_ptr<char[]> buffer; uint64_t length = - encoder_.SerializeDataFrameHeader(/* payload_length = */ 5, &buffer); + HttpEncoder::SerializeDataFrameHeader(/* payload_length = */ 5, &buffer); char output[] = {// type (DATA) 0x00, // length @@ -30,10 +24,10 @@ QUIC_ARRAYSIZE(output)); } -TEST_F(HttpEncoderTest, SerializeHeadersFrameHeader) { +TEST(HttpEncoderTest, SerializeHeadersFrameHeader) { std::unique_ptr<char[]> buffer; - uint64_t length = - encoder_.SerializeHeadersFrameHeader(/* payload_length = */ 7, &buffer); + uint64_t length = HttpEncoder::SerializeHeadersFrameHeader( + /* payload_length = */ 7, &buffer); char output[] = {// type (HEADERS) 0x01, // length @@ -43,7 +37,7 @@ QUIC_ARRAYSIZE(output)); } -TEST_F(HttpEncoderTest, SerializePriorityFrame) { +TEST(HttpEncoderTest, SerializePriorityFrame) { PriorityFrame priority; priority.prioritized_type = REQUEST_STREAM; priority.dependency_type = REQUEST_STREAM; @@ -65,7 +59,7 @@ 0xFF}; std::unique_ptr<char[]> buffer; - uint64_t length = encoder_.SerializePriorityFrame(priority, &buffer); + uint64_t length = HttpEncoder::SerializePriorityFrame(priority, &buffer); EXPECT_EQ(QUIC_ARRAYSIZE(output), length); CompareCharArraysWithHexError("PRIORITY", buffer.get(), length, output, QUIC_ARRAYSIZE(output)); @@ -86,7 +80,7 @@ 0x04, // weight 0xff}; - length = encoder_.SerializePriorityFrame(priority2, &buffer); + length = HttpEncoder::SerializePriorityFrame(priority2, &buffer); EXPECT_EQ(QUIC_ARRAYSIZE(output2), length); CompareCharArraysWithHexError("PRIORITY", buffer.get(), length, output2, QUIC_ARRAYSIZE(output2)); @@ -104,13 +98,13 @@ 0xf8, // weight 0xff}; - length = encoder_.SerializePriorityFrame(priority3, &buffer); + length = HttpEncoder::SerializePriorityFrame(priority3, &buffer); EXPECT_EQ(QUIC_ARRAYSIZE(output3), length); CompareCharArraysWithHexError("PRIORITY", buffer.get(), length, output3, QUIC_ARRAYSIZE(output3)); } -TEST_F(HttpEncoderTest, SerializeCancelPushFrame) { +TEST(HttpEncoderTest, SerializeCancelPushFrame) { CancelPushFrame cancel_push; cancel_push.push_id = 0x01; char output[] = {// type (CANCEL_PUSH) @@ -120,13 +114,13 @@ // Push Id 0x01}; std::unique_ptr<char[]> buffer; - uint64_t length = encoder_.SerializeCancelPushFrame(cancel_push, &buffer); + uint64_t length = HttpEncoder::SerializeCancelPushFrame(cancel_push, &buffer); EXPECT_EQ(QUIC_ARRAYSIZE(output), length); CompareCharArraysWithHexError("CANCEL_PUSH", buffer.get(), length, output, QUIC_ARRAYSIZE(output)); } -TEST_F(HttpEncoderTest, SerializeSettingsFrame) { +TEST(HttpEncoderTest, SerializeSettingsFrame) { SettingsFrame settings; settings.values[1] = 2; settings.values[6] = 5; @@ -148,13 +142,13 @@ // content 0x04}; std::unique_ptr<char[]> buffer; - uint64_t length = encoder_.SerializeSettingsFrame(settings, &buffer); + uint64_t length = HttpEncoder::SerializeSettingsFrame(settings, &buffer); EXPECT_EQ(QUIC_ARRAYSIZE(output), length); CompareCharArraysWithHexError("SETTINGS", buffer.get(), length, output, QUIC_ARRAYSIZE(output)); } -TEST_F(HttpEncoderTest, SerializePushPromiseFrameWithOnlyPushId) { +TEST(HttpEncoderTest, SerializePushPromiseFrameWithOnlyPushId) { PushPromiseFrame push_promise; push_promise.push_id = 0x01; push_promise.headers = "Headers"; @@ -165,14 +159,14 @@ // Push Id 0x01}; std::unique_ptr<char[]> buffer; - uint64_t length = - encoder_.SerializePushPromiseFrameWithOnlyPushId(push_promise, &buffer); + uint64_t length = HttpEncoder::SerializePushPromiseFrameWithOnlyPushId( + push_promise, &buffer); EXPECT_EQ(QUIC_ARRAYSIZE(output), length); CompareCharArraysWithHexError("PUSH_PROMISE", buffer.get(), length, output, QUIC_ARRAYSIZE(output)); } -TEST_F(HttpEncoderTest, SerializeGoAwayFrame) { +TEST(HttpEncoderTest, SerializeGoAwayFrame) { GoAwayFrame goaway; goaway.stream_id = 0x1; char output[] = {// type (GOAWAY) @@ -182,13 +176,13 @@ // StreamId 0x01}; std::unique_ptr<char[]> buffer; - uint64_t length = encoder_.SerializeGoAwayFrame(goaway, &buffer); + uint64_t length = HttpEncoder::SerializeGoAwayFrame(goaway, &buffer); EXPECT_EQ(QUIC_ARRAYSIZE(output), length); CompareCharArraysWithHexError("GOAWAY", buffer.get(), length, output, QUIC_ARRAYSIZE(output)); } -TEST_F(HttpEncoderTest, SerializeMaxPushIdFrame) { +TEST(HttpEncoderTest, SerializeMaxPushIdFrame) { MaxPushIdFrame max_push_id; max_push_id.push_id = 0x1; char output[] = {// type (MAX_PUSH_ID) @@ -198,13 +192,13 @@ // Push Id 0x01}; std::unique_ptr<char[]> buffer; - uint64_t length = encoder_.SerializeMaxPushIdFrame(max_push_id, &buffer); + uint64_t length = HttpEncoder::SerializeMaxPushIdFrame(max_push_id, &buffer); EXPECT_EQ(QUIC_ARRAYSIZE(output), length); CompareCharArraysWithHexError("MAX_PUSH_ID", buffer.get(), length, output, QUIC_ARRAYSIZE(output)); } -TEST_F(HttpEncoderTest, SerializeDuplicatePushFrame) { +TEST(HttpEncoderTest, SerializeDuplicatePushFrame) { DuplicatePushFrame duplicate_push; duplicate_push.push_id = 0x1; char output[] = {// type (DUPLICATE_PUSH) @@ -215,7 +209,7 @@ 0x01}; std::unique_ptr<char[]> buffer; uint64_t length = - encoder_.SerializeDuplicatePushFrame(duplicate_push, &buffer); + HttpEncoder::SerializeDuplicatePushFrame(duplicate_push, &buffer); EXPECT_EQ(QUIC_ARRAYSIZE(output), length); CompareCharArraysWithHexError("DUPLICATE_PUSH", buffer.get(), length, output, QUIC_ARRAYSIZE(output));
diff --git a/quic/core/http/quic_receive_control_stream_test.cc b/quic/core/http/quic_receive_control_stream_test.cc index 7374513..8418766 100644 --- a/quic/core/http/quic_receive_control_stream_test.cc +++ b/quic/core/http/quic_receive_control_stream_test.cc
@@ -103,18 +103,16 @@ Perspective perspective() const { return GetParam().perspective; } std::string EncodeSettings(const SettingsFrame& settings) { - HttpEncoder encoder; std::unique_ptr<char[]> buffer; QuicByteCount settings_frame_length = - encoder.SerializeSettingsFrame(settings, &buffer); + HttpEncoder::SerializeSettingsFrame(settings, &buffer); return std::string(buffer.get(), settings_frame_length); } std::string PriorityFrame(const PriorityFrame& frame) { - HttpEncoder encoder; std::unique_ptr<char[]> priority_buffer; QuicByteCount priority_frame_length = - encoder.SerializePriorityFrame(frame, &priority_buffer); + HttpEncoder::SerializePriorityFrame(frame, &priority_buffer); return std::string(priority_buffer.get(), priority_frame_length); } @@ -216,10 +214,9 @@ TEST_P(QuicReceiveControlStreamTest, ReceiveWrongFrame) { DuplicatePushFrame dup; dup.push_id = 0x1; - HttpEncoder encoder; std::unique_ptr<char[]> buffer; QuicByteCount header_length = - encoder.SerializeDuplicatePushFrame(dup, &buffer); + HttpEncoder::SerializeDuplicatePushFrame(dup, &buffer); std::string data = std::string(buffer.get(), header_length); QuicStreamFrame frame(receive_control_stream_->id(), false, 1, data); @@ -249,10 +246,10 @@ TEST_P(QuicReceiveControlStreamTest, ReceiveGoAwayFrame) { GoAwayFrame goaway; goaway.stream_id = 0x00; - HttpEncoder encoder; std::unique_ptr<char[]> buffer; - QuicByteCount header_length = encoder.SerializeGoAwayFrame(goaway, &buffer); + QuicByteCount header_length = + HttpEncoder::SerializeGoAwayFrame(goaway, &buffer); std::string data = std::string(buffer.get(), header_length); QuicStreamFrame frame(receive_control_stream_->id(), false, 1, data); @@ -273,9 +270,8 @@ push_promise.push_id = 0x01; push_promise.headers = "Headers"; std::unique_ptr<char[]> buffer; - HttpEncoder encoder; - uint64_t length = - encoder.SerializePushPromiseFrameWithOnlyPushId(push_promise, &buffer); + uint64_t length = HttpEncoder::SerializePushPromiseFrameWithOnlyPushId( + push_promise, &buffer); QuicStreamFrame frame(receive_control_stream_->id(), false, 1, buffer.get(), length); // TODO(lassey) Check for HTTP_WRONG_STREAM error code.
diff --git a/quic/core/http/quic_send_control_stream.cc b/quic/core/http/quic_send_control_stream.cc index 9891d66..ed7cd7f 100644 --- a/quic/core/http/quic_send_control_stream.cc +++ b/quic/core/http/quic_send_control_stream.cc
@@ -59,7 +59,7 @@ std::unique_ptr<char[]> buffer; QuicByteCount frame_length = - encoder_.SerializeSettingsFrame(settings, &buffer); + HttpEncoder::SerializeSettingsFrame(settings, &buffer); QUIC_DVLOG(1) << "Control stream " << id() << " is writing settings frame " << settings; QuicSpdySession* spdy_session = static_cast<QuicSpdySession*>(session()); @@ -76,7 +76,7 @@ MaybeSendSettingsFrame(); std::unique_ptr<char[]> buffer; QuicByteCount frame_length = - encoder_.SerializePriorityFrame(priority, &buffer); + HttpEncoder::SerializePriorityFrame(priority, &buffer); QUIC_DVLOG(1) << "Control Stream " << id() << " is writing " << priority; WriteOrBufferData(QuicStringPiece(buffer.get(), frame_length), false, nullptr); @@ -89,7 +89,8 @@ MaxPushIdFrame frame; frame.push_id = max_push_id; std::unique_ptr<char[]> buffer; - QuicByteCount frame_length = encoder_.SerializeMaxPushIdFrame(frame, &buffer); + QuicByteCount frame_length = + HttpEncoder::SerializeMaxPushIdFrame(frame, &buffer); WriteOrBufferData(QuicStringPiece(buffer.get(), frame_length), /*fin = */ false, nullptr); } @@ -107,7 +108,8 @@ } frame.stream_id = stream_id; std::unique_ptr<char[]> buffer; - QuicByteCount frame_length = encoder_.SerializeGoAwayFrame(frame, &buffer); + QuicByteCount frame_length = + HttpEncoder::SerializeGoAwayFrame(frame, &buffer); WriteOrBufferData(QuicStringPiece(buffer.get(), frame_length), false, nullptr); }
diff --git a/quic/core/http/quic_send_control_stream.h b/quic/core/http/quic_send_control_stream.h index 414066d..ac946d3 100644 --- a/quic/core/http/quic_send_control_stream.h +++ b/quic/core/http/quic_send_control_stream.h
@@ -51,7 +51,6 @@ void OnDataAvailable() override { QUIC_NOTREACHED(); } private: - HttpEncoder encoder_; // Track if a settings frame is already sent. bool settings_sent_;
diff --git a/quic/core/http/quic_send_control_stream_test.cc b/quic/core/http/quic_send_control_stream_test.cc index a06a319..de2e705 100644 --- a/quic/core/http/quic_send_control_stream_test.cc +++ b/quic/core/http/quic_send_control_stream_test.cc
@@ -93,7 +93,6 @@ MockAlarmFactory alarm_factory_; StrictMock<MockQuicConnection>* connection_; StrictMock<MockQuicSpdySession> session_; - HttpEncoder encoder_; QuicSendControlStream* send_control_stream_; };
diff --git a/quic/core/http/quic_spdy_client_stream_test.cc b/quic/core/http/quic_spdy_client_stream_test.cc index 84a207a..c9cd8d2 100644 --- a/quic/core/http/quic_spdy_client_stream_test.cc +++ b/quic/core/http/quic_spdy_client_stream_test.cc
@@ -96,7 +96,6 @@ std::unique_ptr<StreamVisitor> stream_visitor_; SpdyHeaderBlock headers_; std::string body_; - HttpEncoder encoder_; }; INSTANTIATE_TEST_SUITE_P(Tests, @@ -122,7 +121,7 @@ headers); std::unique_ptr<char[]> buffer; QuicByteCount header_length = - encoder_.SerializeDataFrameHeader(body_.length(), &buffer); + HttpEncoder::SerializeDataFrameHeader(body_.length(), &buffer); std::string header = std::string(buffer.get(), header_length); std::string data = VersionUsesHttp3(connection_->transport_version()) ? header + body_ @@ -153,7 +152,7 @@ headers); std::unique_ptr<char[]> buffer; QuicByteCount header_length = - encoder_.SerializeDataFrameHeader(body_.length(), &buffer); + HttpEncoder::SerializeDataFrameHeader(body_.length(), &buffer); std::string header = std::string(buffer.get(), header_length); std::string data = VersionUsesHttp3(connection_->transport_version()) ? header + body_ @@ -178,7 +177,7 @@ EXPECT_EQ(200, stream_->response_code()); std::unique_ptr<char[]> buffer; QuicByteCount header_length = - encoder_.SerializeDataFrameHeader(large_body.length(), &buffer); + HttpEncoder::SerializeDataFrameHeader(large_body.length(), &buffer); std::string header = std::string(buffer.get(), header_length); std::string data = VersionUsesHttp3(connection_->transport_version()) ? header + large_body @@ -222,7 +221,7 @@ // received, as well as all data. std::unique_ptr<char[]> buffer; QuicByteCount header_length = - encoder_.SerializeDataFrameHeader(body_.length(), &buffer); + HttpEncoder::SerializeDataFrameHeader(body_.length(), &buffer); std::string header = std::string(buffer.get(), header_length); std::string data = VersionUsesHttp3(connection_->transport_version()) ? header + body_
diff --git a/quic/core/http/quic_spdy_session_test.cc b/quic/core/http/quic_spdy_session_test.cc index 23b1cd6..2c14d12 100644 --- a/quic/core/http/quic_spdy_session_test.cc +++ b/quic/core/http/quic_spdy_session_test.cc
@@ -13,6 +13,7 @@ #include "net/third_party/quiche/src/quic/core/crypto/null_encrypter.h" #include "net/third_party/quiche/src/quic/core/frames/quic_stream_frame.h" #include "net/third_party/quiche/src/quic/core/http/http_constants.h" +#include "net/third_party/quiche/src/quic/core/http/http_encoder.h" #include "net/third_party/quiche/src/quic/core/quic_config.h" #include "net/third_party/quiche/src/quic/core/quic_crypto_stream.h" #include "net/third_party/quiche/src/quic/core/quic_data_writer.h" @@ -398,9 +399,8 @@ } std::string EncodeSettings(const SettingsFrame& settings) { - HttpEncoder encoder; std::unique_ptr<char[]> buffer; - auto header_length = encoder.SerializeSettingsFrame(settings, &buffer); + auto header_length = HttpEncoder::SerializeSettingsFrame(settings, &buffer); return std::string(buffer.get(), header_length); } @@ -2305,10 +2305,9 @@ // HEADERS frame referencing first dynamic table entry. std::string headers_payload = QuicTextUtils::HexDecode("020080"); std::unique_ptr<char[]> headers_buffer; - HttpEncoder encoder; QuicByteCount headers_frame_header_length = - encoder.SerializeHeadersFrameHeader(headers_payload.length(), - &headers_buffer); + HttpEncoder::SerializeHeadersFrameHeader(headers_payload.length(), + &headers_buffer); QuicStringPiece headers_frame_header(headers_buffer.get(), headers_frame_header_length); std::string headers = QuicStrCat(headers_frame_header, headers_payload); @@ -2340,10 +2339,9 @@ // HEADERS frame referencing first dynamic table entry. std::string headers_payload = QuicTextUtils::HexDecode("020080"); std::unique_ptr<char[]> headers_buffer; - HttpEncoder encoder; QuicByteCount headers_frame_header_length = - encoder.SerializeHeadersFrameHeader(headers_payload.length(), - &headers_buffer); + HttpEncoder::SerializeHeadersFrameHeader(headers_payload.length(), + &headers_buffer); QuicStringPiece headers_frame_header(headers_buffer.get(), headers_frame_header_length); std::string headers = QuicStrCat(headers_frame_header, headers_payload);
diff --git a/quic/core/http/quic_spdy_stream.cc b/quic/core/http/quic_spdy_stream.cc index c684916..08beb8c 100644 --- a/quic/core/http/quic_spdy_stream.cc +++ b/quic/core/http/quic_spdy_stream.cc
@@ -297,7 +297,7 @@ // Write frame header. std::unique_ptr<char[]> buffer; QuicByteCount header_length = - encoder_.SerializeDataFrameHeader(data.length(), &buffer); + HttpEncoder::SerializeDataFrameHeader(data.length(), &buffer); unacked_frame_headers_offsets_.Add( send_buffer().stream_offset(), send_buffer().stream_offset() + header_length); @@ -358,7 +358,7 @@ DCHECK(VersionUsesHttp3(transport_version())); std::unique_ptr<char[]> push_promise_frame_with_id; const size_t push_promise_frame_length = - encoder_.SerializePushPromiseFrameWithOnlyPushId( + HttpEncoder::SerializePushPromiseFrameWithOnlyPushId( frame, &push_promise_frame_with_id); unacked_frame_headers_offsets_.Add(send_buffer().stream_offset(), @@ -401,7 +401,7 @@ std::unique_ptr<char[]> buffer; QuicByteCount header_length = - encoder_.SerializeDataFrameHeader(slices.total_length(), &buffer); + HttpEncoder::SerializeDataFrameHeader(slices.total_length(), &buffer); if (!CanWriteNewDataAfterData(header_length)) { return {0, false}; } @@ -1041,8 +1041,8 @@ // Write HEADERS frame. std::unique_ptr<char[]> headers_frame_header; const size_t headers_frame_header_length = - encoder_.SerializeHeadersFrameHeader(encoded_headers.size(), - &headers_frame_header); + HttpEncoder::SerializeHeadersFrameHeader(encoded_headers.size(), + &headers_frame_header); unacked_frame_headers_offsets_.Add( send_buffer().stream_offset(), send_buffer().stream_offset() + headers_frame_header_length);
diff --git a/quic/core/http/quic_spdy_stream.h b/quic/core/http/quic_spdy_stream.h index 6da102b..ea413cf 100644 --- a/quic/core/http/quic_spdy_stream.h +++ b/quic/core/http/quic_spdy_stream.h
@@ -305,8 +305,6 @@ // The parsed trailers received from the peer. spdy::SpdyHeaderBlock received_trailers_; - // Http encoder for writing streams. - HttpEncoder encoder_; // Headers accumulator for decoding HEADERS frame payload. std::unique_ptr<QpackDecodedHeadersAccumulator> qpack_decoded_headers_accumulator_;
diff --git a/quic/core/http/quic_spdy_stream_test.cc b/quic/core/http/quic_spdy_stream_test.cc index 2db475e..c080982 100644 --- a/quic/core/http/quic_spdy_stream_test.cc +++ b/quic/core/http/quic_spdy_stream_test.cc
@@ -280,7 +280,8 @@ std::string HeadersFrame(QuicStringPiece payload) { std::unique_ptr<char[]> headers_buffer; QuicByteCount headers_frame_header_length = - encoder_.SerializeHeadersFrameHeader(payload.length(), &headers_buffer); + HttpEncoder::SerializeHeadersFrameHeader(payload.length(), + &headers_buffer); QuicStringPiece headers_frame_header(headers_buffer.get(), headers_frame_header_length); return QuicStrCat(headers_frame_header, payload); @@ -289,7 +290,7 @@ std::string DataFrame(QuicStringPiece payload) { std::unique_ptr<char[]> data_buffer; QuicByteCount data_frame_header_length = - encoder_.SerializeDataFrameHeader(payload.length(), &data_buffer); + HttpEncoder::SerializeDataFrameHeader(payload.length(), &data_buffer); QuicStringPiece data_frame_header(data_buffer.get(), data_frame_header_length); return QuicStrCat(data_frame_header, payload); @@ -323,8 +324,6 @@ TestStream* stream2_; SpdyHeaderBlock headers_; - - HttpEncoder encoder_; }; INSTANTIATE_TEST_SUITE_P(Tests, @@ -469,7 +468,8 @@ GoAwayFrame goaway; goaway.stream_id = 0x1; std::unique_ptr<char[]> buffer; - QuicByteCount header_length = encoder_.SerializeGoAwayFrame(goaway, &buffer); + QuicByteCount header_length = + HttpEncoder::SerializeGoAwayFrame(goaway, &buffer); std::string data = std::string(buffer.get(), header_length); EXPECT_EQ("", stream_->data()); @@ -763,7 +763,8 @@ if (UsesHttp3()) { std::unique_ptr<char[]> buffer; - header_length = encoder_.SerializeDataFrameHeader(body.length(), &buffer); + header_length = + HttpEncoder::SerializeDataFrameHeader(body.length(), &buffer); std::string header = std::string(buffer.get(), header_length); data = header + body; } else { @@ -812,7 +813,8 @@ if (UsesHttp3()) { std::unique_ptr<char[]> buffer; - header_length = encoder_.SerializeDataFrameHeader(body.length(), &buffer); + header_length = + HttpEncoder::SerializeDataFrameHeader(body.length(), &buffer); std::string header = std::string(buffer.get(), header_length); data = header + body; } else { @@ -882,12 +884,13 @@ if (UsesHttp3()) { body = std::string(kWindow / 4 - 2, 'a'); std::unique_ptr<char[]> buffer; - header_length = encoder_.SerializeDataFrameHeader(body.length(), &buffer); + header_length = + HttpEncoder::SerializeDataFrameHeader(body.length(), &buffer); std::string header = std::string(buffer.get(), header_length); data = header + body; std::unique_ptr<char[]> buffer2; QuicByteCount header_length2 = - encoder_.SerializeDataFrameHeader(body2.length(), &buffer2); + HttpEncoder::SerializeDataFrameHeader(body2.length(), &buffer2); std::string header2 = std::string(buffer2.get(), header_length2); data2 = header2 + body2; } else { @@ -1302,7 +1305,7 @@ QuicByteCount header_length = 0; if (UsesHttp3()) { std::unique_ptr<char[]> buf; - header_length = encoder_.SerializeDataFrameHeader(body.length(), &buf); + header_length = HttpEncoder::SerializeDataFrameHeader(body.length(), &buf); } stream_->WriteOrBufferBody(body, false); @@ -1652,10 +1655,11 @@ std::unique_ptr<char[]> buffer; QuicByteCount header_length = - encoder_.SerializeDataFrameHeader(body.length(), &buffer); + HttpEncoder::SerializeDataFrameHeader(body.length(), &buffer); std::string header = std::string(buffer.get(), header_length); - header_length = encoder_.SerializeDataFrameHeader(body2.length(), &buffer); + header_length = + HttpEncoder::SerializeDataFrameHeader(body2.length(), &buffer); std::string header2 = std::string(buffer.get(), header_length); EXPECT_CALL(*mock_ack_listener, OnPacketAcked(body.length(), _)); @@ -2268,9 +2272,8 @@ push_promise.push_id = 0x01; push_promise.headers = headers; std::unique_ptr<char[]> buffer; - HttpEncoder encoder; - uint64_t length = - encoder.SerializePushPromiseFrameWithOnlyPushId(push_promise, &buffer); + uint64_t length = HttpEncoder::SerializePushPromiseFrameWithOnlyPushId( + push_promise, &buffer); std::string data = std::string(buffer.get(), length) + headers; QuicStreamFrame frame(stream_->id(), false, 0, data);
diff --git a/quic/tools/quic_simple_server_session_test.cc b/quic/tools/quic_simple_server_session_test.cc index b127885..8623152 100644 --- a/quic/tools/quic_simple_server_session_test.cc +++ b/quic/tools/quic_simple_server_session_test.cc
@@ -10,6 +10,7 @@ #include "net/third_party/quiche/src/quic/core/crypto/quic_crypto_server_config.h" #include "net/third_party/quiche/src/quic/core/crypto/quic_random.h" +#include "net/third_party/quiche/src/quic/core/http/http_encoder.h" #include "net/third_party/quiche/src/quic/core/proto/cached_network_parameters_proto.h" #include "net/third_party/quiche/src/quic/core/quic_connection.h" #include "net/third_party/quiche/src/quic/core/quic_crypto_server_stream.h" @@ -653,10 +654,9 @@ std::string data; data_frame_header_length = 0; if (VersionUsesHttp3(connection_->transport_version())) { - HttpEncoder encoder; std::unique_ptr<char[]> buffer; data_frame_header_length = - encoder.SerializeDataFrameHeader(body.length(), &buffer); + HttpEncoder::SerializeDataFrameHeader(body.length(), &buffer); std::string header(buffer.get(), data_frame_header_length); data = header + body; } else {
diff --git a/quic/tools/quic_simple_server_stream_test.cc b/quic/tools/quic_simple_server_stream_test.cc index 783dba0..41ea2f6 100644 --- a/quic/tools/quic_simple_server_stream_test.cc +++ b/quic/tools/quic_simple_server_stream_test.cc
@@ -8,6 +8,7 @@ #include <memory> #include <utility> +#include "net/third_party/quiche/src/quic/core/http/http_encoder.h" #include "net/third_party/quiche/src/quic/core/http/spdy_utils.h" #include "net/third_party/quiche/src/quic/core/quic_utils.h" #include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.h" @@ -248,7 +249,6 @@ std::unique_ptr<QuicBackendResponse> quic_response_; std::string body_; QuicHeaderList header_list_; - HttpEncoder encoder_; }; INSTANTIATE_TEST_SUITE_P(Tests, @@ -262,7 +262,7 @@ stream_->OnStreamHeaderList(false, kFakeFrameLen, header_list_); std::unique_ptr<char[]> buffer; QuicByteCount header_length = - encoder_.SerializeDataFrameHeader(body_.length(), &buffer); + HttpEncoder::SerializeDataFrameHeader(body_.length(), &buffer); std::string header = std::string(buffer.get(), header_length); std::string data = UsesHttp3() ? header + body_ : body_; stream_->OnStreamFrame( @@ -280,7 +280,7 @@ stream_->OnStreamHeaderList(false, kFakeFrameLen, header_list_); std::unique_ptr<char[]> buffer; QuicByteCount header_length = - encoder_.SerializeDataFrameHeader(body_.length(), &buffer); + HttpEncoder::SerializeDataFrameHeader(body_.length(), &buffer); std::string header = std::string(buffer.get(), header_length); std::string data = UsesHttp3() ? header + body_ : body_; stream_->OnStreamFrame( @@ -321,7 +321,7 @@ stream_->OnStreamHeaderList(false, kFakeFrameLen, header_list_); std::unique_ptr<char[]> buffer; QuicByteCount header_length = - encoder_.SerializeDataFrameHeader(body_.length(), &buffer); + HttpEncoder::SerializeDataFrameHeader(body_.length(), &buffer); std::string header = std::string(buffer.get(), header_length); std::string data = UsesHttp3() ? header + body_ : body_; @@ -330,7 +330,7 @@ // Content length is still 11. This will register as an error and we won't // accept the bytes. header_length = - encoder_.SerializeDataFrameHeader(large_body.length(), &buffer); + HttpEncoder::SerializeDataFrameHeader(large_body.length(), &buffer); header = std::string(buffer.get(), header_length); std::string data2 = UsesHttp3() ? header + large_body : large_body; stream_->OnStreamFrame( @@ -355,7 +355,7 @@ std::string body = "Yummm"; std::unique_ptr<char[]> buffer; QuicByteCount header_length = - encoder_.SerializeDataFrameHeader(body.length(), &buffer); + HttpEncoder::SerializeDataFrameHeader(body.length(), &buffer); memory_cache_backend_.AddResponse("www.google.com", "/bar", std::move(response_headers_), body); @@ -390,7 +390,7 @@ std::unique_ptr<char[]> buffer; QuicByteCount header_length = - encoder_.SerializeDataFrameHeader(body.length(), &buffer); + HttpEncoder::SerializeDataFrameHeader(body.length(), &buffer); memory_cache_backend_.AddResponse("www.google.com", "/bar", std::move(response_headers_), body); @@ -455,7 +455,7 @@ std::unique_ptr<char[]> buffer; QuicByteCount header_length = - encoder_.SerializeDataFrameHeader(body.length(), &buffer); + HttpEncoder::SerializeDataFrameHeader(body.length(), &buffer); memory_cache_backend_.AddResponse("www.google.com", "/bar", std::move(response_headers_), body); @@ -483,7 +483,7 @@ std::string body = "Yummm"; std::unique_ptr<char[]> buffer; QuicByteCount header_length = - encoder_.SerializeDataFrameHeader(body.length(), &buffer); + HttpEncoder::SerializeDataFrameHeader(body.length(), &buffer); QuicBackendResponse::ServerPushInfo push_info( QuicUrl(host, "/bar"), spdy::SpdyHeaderBlock(), QuicStream::kDefaultPriority, "Push body"); @@ -555,7 +555,7 @@ const std::string kBody = "Hello"; std::unique_ptr<char[]> buffer; QuicByteCount header_length = - encoder_.SerializeDataFrameHeader(kBody.length(), &buffer); + HttpEncoder::SerializeDataFrameHeader(kBody.length(), &buffer); memory_cache_backend_.AddResponse(kHost, kPath, std::move(response_headers_), kBody);