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