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);
