[Indeterminate-Length BHTTP] Adding response encoder

PiperOrigin-RevId: 793739849
diff --git a/quiche/binary_http/binary_http_message.cc b/quiche/binary_http/binary_http_message.cc
index bc7a9b0..5b06bf3 100644
--- a/quiche/binary_http/binary_http_message.cc
+++ b/quiche/binary_http/binary_http_message.cc
@@ -5,6 +5,7 @@
 #include <functional>
 #include <iterator>
 #include <memory>
+#include <optional>
 #include <ostream>
 #include <string>
 #include <utility>
@@ -19,6 +20,7 @@
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
+#include "absl/types/span.h"
 #include "quiche/common/quiche_callbacks.h"
 #include "quiche/common/quiche_data_reader.h"
 #include "quiche/common/quiche_data_writer.h"
@@ -29,15 +31,9 @@
 constexpr uint64_t kKnownLengthRequestFraming = 0;
 constexpr uint64_t kKnownLengthResponseFraming = 1;
 constexpr uint64_t kIndeterminateLengthRequestFraming = 2;
+constexpr uint64_t kIndeterminateLengthResponseFraming = 3;
 constexpr uint64_t kContentTerminator = 0;
 
-// A view of a field name and value. Used to pass around a field without owning
-// or copying the backing data.
-struct FieldView {
-  absl::string_view name;
-  absl::string_view value;
-};
-
 bool ReadStringValue(quiche::QuicheDataReader& reader, std::string& data) {
   absl::string_view data_view;
   if (!reader.ReadStringPieceVarInt62(&data_view)) {
@@ -72,8 +68,8 @@
 
 // Decodes a header/trailer name and value. This takes a length which represents
 // only the name length.
-absl::StatusOr<FieldView> DecodeField(QuicheDataReader& reader,
-                                      uint64_t name_length) {
+absl::StatusOr<BinaryHttpMessage::FieldView> DecodeField(
+    QuicheDataReader& reader, uint64_t name_length) {
   absl::string_view name;
   if (!reader.ReadStringPiece(&name, name_length)) {
     return absl::OutOfRangeError("Not enough data to read field name.");
@@ -82,7 +78,7 @@
   if (!reader.ReadStringPieceVarInt62(&value)) {
     return absl::OutOfRangeError("Not enough data to read field value.");
   }
-  return FieldView{name, value};
+  return BinaryHttpMessage::FieldView{name, value};
 }
 
 absl::Status DecodeFields(quiche::QuicheDataReader& reader,
@@ -620,6 +616,191 @@
       absl::StrCat("Unsupported framing type ", framing));
 }
 
+absl::StatusOr<std::string>
+BinaryHttpResponse::IndeterminateLengthEncoder::EncodeFieldSection(
+    std::optional<uint16_t> status_code, absl::Span<FieldView> fields) {
+  uint64_t total_length = 0;
+  if (!framing_indicator_encoded_) {
+    total_length += quiche::QuicheDataWriter::GetVarInt62Len(
+        kIndeterminateLengthResponseFraming);
+  }
+  if (status_code.has_value()) {
+    total_length += QuicheDataWriter::GetVarInt62Len(*status_code);
+  }
+  for (const auto& field : fields) {
+    uint8_t length = QuicheDataWriter::GetVarInt62Len(field.name.size());
+    if (length == 0) {
+      return absl::InvalidArgumentError("Field name exceeds maximum length.");
+    }
+    total_length += length + field.name.size();
+
+    length = QuicheDataWriter::GetVarInt62Len(field.value.size());
+    if (length == 0) {
+      return absl::InvalidArgumentError("Field value exceeds maximum length.");
+    }
+    total_length += length + field.value.size();
+  }
+  total_length += quiche::QuicheDataWriter::GetVarInt62Len(kContentTerminator);
+
+  std::string data(total_length, '\0');
+  QuicheDataWriter writer(total_length, data.data());
+
+  if (!framing_indicator_encoded_) {
+    if (!writer.WriteVarInt62(kIndeterminateLengthResponseFraming)) {
+      return absl::InternalError("Failed to write framing indicator.");
+    }
+    framing_indicator_encoded_ = true;
+  }
+  if (status_code.has_value() && !writer.WriteVarInt62(*status_code)) {
+    return absl::InternalError("Failed to write status code.");
+  }
+  for (const auto& field : fields) {
+    if (!writer.WriteStringPieceVarInt62(absl::AsciiStrToLower(field.name))) {
+      return absl::InternalError("Failed to write field name.");
+    }
+    if (!writer.WriteStringPieceVarInt62(field.value)) {
+      return absl::InternalError("Failed to write field value.");
+    }
+  }
+  if (!writer.WriteVarInt62(kContentTerminator)) {
+    return absl::InternalError("Failed to write content terminator.");
+  }
+  if (writer.remaining() != 0) {
+    return absl::InternalError("Failed to write all data.");
+  }
+  return data;
+}
+
+std::string
+BinaryHttpResponse::IndeterminateLengthEncoder::GetMessageSectionString(
+    MessageSection section) const {
+  switch (section) {
+    case MessageSection::kInformationalResponseOrHeader:
+      return "InformationalResponseOrHeader";
+    case MessageSection::kBody:
+      return "Body";
+    case MessageSection::kTrailer:
+      return "Trailer";
+    case MessageSection::kEnd:
+      return "End";
+    default:
+      return "Unknown";
+  }
+}
+
+absl::StatusOr<std::string>
+BinaryHttpResponse::IndeterminateLengthEncoder::EncodeInformationalResponse(
+    uint16_t status_code, absl::Span<FieldView> fields) {
+  if (current_section_ != MessageSection::kInformationalResponseOrHeader) {
+    current_section_ = MessageSection::kEnd;
+    return absl::InvalidArgumentError(absl::StrCat(
+        "EncodeInformationalResponse called in incorrect section: ",
+        GetMessageSectionString(current_section_)));
+  }
+  if (status_code < 100 || status_code > 199) {
+    current_section_ = MessageSection::kEnd;
+    return absl::InvalidArgumentError(absl::StrCat(
+        "Invalid informational response status code: ", status_code));
+  }
+
+  absl::StatusOr<std::string> data = EncodeFieldSection(status_code, fields);
+  if (!data.ok()) {
+    current_section_ = MessageSection::kEnd;
+  }
+
+  return data;
+}
+
+absl::StatusOr<std::string>
+BinaryHttpResponse::IndeterminateLengthEncoder::EncodeHeaders(
+    uint16_t status_code, absl::Span<FieldView> headers) {
+  if (current_section_ != MessageSection::kInformationalResponseOrHeader) {
+    current_section_ = MessageSection::kEnd;
+    return absl::InvalidArgumentError(
+        absl::StrCat("EncodeHeaders called in incorrect section: ",
+                     GetMessageSectionString(current_section_)));
+  }
+  if (status_code < 200 || status_code > 599) {
+    current_section_ = MessageSection::kEnd;
+    return absl::InvalidArgumentError(
+        absl::StrCat("Invalid response status code: ", status_code));
+  }
+
+  absl::StatusOr<std::string> data = EncodeFieldSection(status_code, headers);
+  if (!data.ok()) {
+    current_section_ = MessageSection::kEnd;
+    return data;
+  }
+  current_section_ = MessageSection::kBody;
+  return data;
+}
+
+absl::StatusOr<std::string>
+BinaryHttpResponse::IndeterminateLengthEncoder::EncodeBodyChunks(
+    absl::Span<absl::string_view> body_chunks, bool body_chunks_done) {
+  if (current_section_ != MessageSection::kBody) {
+    current_section_ = MessageSection::kEnd;
+    return absl::InvalidArgumentError(
+        absl::StrCat("EncodeBodyChunks called in incorrect section: ",
+                     GetMessageSectionString(current_section_)));
+  }
+  uint64_t total_length = 0;
+  for (const auto& body_chunk : body_chunks) {
+    uint8_t body_chunk_var_int_length =
+        QuicheDataWriter::GetVarInt62Len(body_chunk.size());
+    if (body_chunk_var_int_length == 0) {
+      current_section_ = MessageSection::kEnd;
+      return absl::InvalidArgumentError(
+          "Body chunk size exceeds maximum length.");
+    }
+    total_length += body_chunk_var_int_length + body_chunk.size();
+  }
+  if (body_chunks_done) {
+    total_length +=
+        quiche::QuicheDataWriter::GetVarInt62Len(kContentTerminator);
+  }
+
+  std::string data(total_length, '\0');
+  QuicheDataWriter writer(total_length, data.data());
+
+  for (const auto& body_chunk : body_chunks) {
+    if (!writer.WriteStringPieceVarInt62(body_chunk)) {
+      current_section_ = MessageSection::kEnd;
+      return absl::InternalError("Failed to write body chunk.");
+    }
+  }
+  if (body_chunks_done) {
+    if (!writer.WriteVarInt62(kContentTerminator)) {
+      current_section_ = MessageSection::kEnd;
+      return absl::InternalError("Failed to write content terminator.");
+    }
+    current_section_ = MessageSection::kTrailer;
+  }
+
+  if (writer.remaining() != 0) {
+    current_section_ = MessageSection::kEnd;
+    return absl::InternalError("Failed to write all data.");
+  }
+  return data;
+}
+
+absl::StatusOr<std::string>
+BinaryHttpResponse::IndeterminateLengthEncoder::EncodeTrailers(
+    absl::Span<FieldView> trailers) {
+  if (current_section_ != MessageSection::kTrailer) {
+    current_section_ = MessageSection::kEnd;
+    return absl::InvalidArgumentError(
+        absl::StrCat("EncodeTrailers called in incorrect section: ",
+                     GetMessageSectionString(current_section_)));
+  }
+
+  absl::StatusOr<std::string> data =
+      EncodeFieldSection(/*status_code=*/std::nullopt, trailers);
+
+  current_section_ = MessageSection::kEnd;
+  return data;
+}
+
 std::string BinaryHttpMessage::DebugString() const {
   std::vector<std::string> headers;
   for (const auto& field : GetHeaderFields()) {
diff --git a/quiche/binary_http/binary_http_message.h b/quiche/binary_http/binary_http_message.h
index 0a28e0a..41a6bc1 100644
--- a/quiche/binary_http/binary_http_message.h
+++ b/quiche/binary_http/binary_http_message.h
@@ -5,6 +5,7 @@
 #include <cstdint>
 #include <functional>
 #include <memory>
+#include <optional>
 #include <ostream>
 #include <string>
 #include <utility>
@@ -14,6 +15,7 @@
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
+#include "absl/types/span.h"
 #include "quiche/common/platform/api/quiche_export.h"
 #include "quiche/common/quiche_data_reader.h"
 #include "quiche/common/quiche_data_writer.h"
@@ -25,6 +27,12 @@
 // https://www.ietf.org/archive/id/draft-ietf-httpbis-binary-message-06.html
 class QUICHE_EXPORT BinaryHttpMessage {
  public:
+  // A view of a field name and value. Used to pass around a field without
+  // owning or copying the backing data.
+  struct QUICHE_EXPORT FieldView {
+    absl::string_view name;
+    absl::string_view value;
+  };
   // Name value pair of either a header or trailer field.
   struct QUICHE_EXPORT Field {
     std::string name;
@@ -364,6 +372,42 @@
     return !(*this == rhs);
   }
 
+  // Provides encoding methods for an Indeterminate-Length BHTTP response. The
+  // encoder keeps track of what has been encoded so far to ensure sections are
+  // encoded in the correct order, this means it can only be used for a single
+  // BHTTP response message.
+  class QUICHE_EXPORT IndeterminateLengthEncoder {
+   public:
+    // Encodes the specified informational response status code, fields, and its
+    // content terminator.
+    absl::StatusOr<std::string> EncodeInformationalResponse(
+        uint16_t status_code, absl::Span<FieldView> fields);
+    // Encodes the specified status code, headers, and its content terminator.
+    absl::StatusOr<std::string> EncodeHeaders(uint16_t status_code,
+                                              absl::Span<FieldView> headers);
+    // Encodes the specified body chunks. If 'body_chunks_done' is true, the
+    // encoded body chunks are followed by the content terminator.
+    absl::StatusOr<std::string> EncodeBodyChunks(
+        absl::Span<absl::string_view> body_chunks, bool body_chunks_done);
+    // Encodes the specified trailers and its content terminator.
+    absl::StatusOr<std::string> EncodeTrailers(absl::Span<FieldView> trailers);
+
+   private:
+    enum class MessageSection {
+      kInformationalResponseOrHeader,
+      kBody,
+      kTrailer,
+      kEnd,
+    };
+    absl::StatusOr<std::string> EncodeFieldSection(
+        std::optional<uint16_t> status_code, absl::Span<FieldView> fields);
+    std::string GetMessageSectionString(MessageSection section) const;
+
+    MessageSection current_section_ =
+        MessageSection::kInformationalResponseOrHeader;
+    bool framing_indicator_encoded_ = false;
+  };
+
  private:
   // Returns Binary Http known length request formatted response.
   absl::StatusOr<std::string> EncodeAsKnownLength() const;
diff --git a/quiche/binary_http/binary_http_message_test.cc b/quiche/binary_http/binary_http_message_test.cc
index 0a6e3d8..d267d9e 100644
--- a/quiche/binary_http/binary_http_message_test.cc
+++ b/quiche/binary_http/binary_http_message_test.cc
@@ -10,9 +10,11 @@
 
 #include "absl/container/flat_hash_map.h"
 #include "absl/status/status.h"
+#include "absl/status/statusor.h"
 #include "absl/strings/escaping.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "absl/types/span.h"
 #include "quiche/common/platform/api/quiche_test.h"
 #include "quiche/common/test_tools/quiche_test_utils.h"
 
@@ -586,6 +588,274 @@
   ExpectTruncatedTrailerSection(message_data);
 }
 
+namespace {
+
+struct ResponseIndeterminateLengthEncoderTestData {
+  std::vector<quiche::BinaryHttpMessage::FieldView> informationalResponse1{
+      {"running", "\"sleep 15\""}};
+  std::vector<BinaryHttpMessage::FieldView> informationalResponse2{
+      {/*uppercase*/ "LINK", "</style.css>; rel=preload; as=style"},
+      {"link", "</script.js>; rel=preload; as=script"},
+      {"longer_header_value",
+       "1111111111111111111111111111111111111111111111111111111111111111"}};
+  std::vector<BinaryHttpMessage::FieldView> headers{
+      {"Date", "Mon, 27 Jul 2009 12:28:53 GMT"},
+      {"Server", "Apache"},
+      {"longer_header_value",
+       "1111111111111111111111111111111111111111111111111111111111111111"}};
+  std::vector<absl::string_view> body_chunks = {
+      "chunk1", "chunk2", "chunk3",
+      "1111111111111111111111111111111111111111111111111111111111111111"};
+  std::vector<BinaryHttpMessage::FieldView> trailers{
+      {"trailer1", "value1"},
+      {"trailer2", "value2"},
+      {"longer_trailer_value",
+       "1111111111111111111111111111111111111111111111111111111111111111"}};
+};
+
+constexpr absl::string_view kEncodedInformationalResponses =
+    "4066"                    // status code: 102
+    "0772756e6e696e67"        // running
+    "0a22736C65657020313522"  // "sleep 15"
+    "00"                      // content terminator
+    "4067"                    // status code: 103
+    "046C696E6B"              // link
+    "233C2F7374796C652E6373733E3B2072656C3D7072656C6F6"
+    "1643B2061733D737479"
+    "6C65"        // </style.css>; rel=preload; as=style
+    "046C696E6B"  // link
+    "243C2F7363726970742E6A733E3B2072656C3D7072656C6F6"
+    "1643B2061733D736372"
+    "697074"  // </script.js>; rel=preload; as=script
+    "136C6F6E6765725F6865616465725F76616C7565"  // longer_header_value
+    "40403131313131313131313131313131313131313131313131313131313131313131313131"
+    "3131313131313131313131313131313131313131313131313131313131"  // 64 1s
+    "00";  // content terminator
+
+constexpr absl::string_view kEncodedResponse =
+    "40C8"        // status code: 200
+    "0464617465"  // date
+    "1D4D6F6E2C203237204A756C20323030392031323A32383A3"
+    "53320474D54"                               // Mon, 27
+                                                // Jul
+                                                // 2009
+                                                // 12:28:53
+                                                // GMT
+    "06736572766572"                            // server
+    "06417061636865"                            // Apache
+    "136C6F6E6765725F6865616465725F76616C7565"  // longer_header_value
+    "40403131313131313131313131313131313131313131313131313131313131313131313131"
+    "3131313131313131313131313131313131313131313131313131313131"  // 64 1s
+    "00"              // content terminator
+    "066368756E6B31"  // chunk1
+    "066368756E6B32"  // chunk2
+    "066368756E6B33"  // chunk3
+    "40403131313131313131313131313131313131313131313131313131313131313131313131"
+    "3131313131313131313131313131313131313131313131313131313131"  // 64 1s
+    "00"                                          // content terminator
+    "08747261696C657231"                          // trailer1
+    "0676616C756531"                              // value1
+    "08747261696C657232"                          // trailer2
+    "0676616C756532"                              // value2
+    "146C6F6E6765725F747261696C65725F76616C7565"  // longer_trailer_value
+    "40403131313131313131313131313131313131313131313131313131313131313131313131"
+    "3131313131313131313131313131313131313131313131313131313131"  // 64 1s
+    "00";
+
+}  // namespace
+
+TEST(ResponseIndeterminateLengthEncoder, WithInformationalResponses) {
+  std::string expected;
+  ASSERT_TRUE(absl::HexStringToBytes(
+      absl::StrCat("03", kEncodedInformationalResponses, kEncodedResponse),
+      &expected));
+
+  BinaryHttpResponse::IndeterminateLengthEncoder encoder;
+  ResponseIndeterminateLengthEncoderTestData test_data;
+  std::string encoded_data;
+
+  absl::StatusOr<std::string> status_or_encoded_data =
+      encoder.EncodeInformationalResponse(
+          102, absl::MakeSpan(test_data.informationalResponse1));
+  QUICHE_EXPECT_OK(status_or_encoded_data);
+  encoded_data += *status_or_encoded_data;
+  status_or_encoded_data = encoder.EncodeInformationalResponse(
+      103, absl::MakeSpan(test_data.informationalResponse2));
+  QUICHE_EXPECT_OK(status_or_encoded_data);
+  encoded_data += *status_or_encoded_data;
+
+  status_or_encoded_data =
+      encoder.EncodeHeaders(200, absl::MakeSpan(test_data.headers));
+  QUICHE_EXPECT_OK(status_or_encoded_data);
+  encoded_data += *status_or_encoded_data;
+
+  status_or_encoded_data =
+      encoder.EncodeBodyChunks(absl::MakeSpan(test_data.body_chunks), true);
+  QUICHE_EXPECT_OK(status_or_encoded_data);
+  encoded_data += *status_or_encoded_data;
+
+  status_or_encoded_data =
+      encoder.EncodeTrailers(absl::MakeSpan(test_data.trailers));
+  QUICHE_EXPECT_OK(status_or_encoded_data);
+  encoded_data += *status_or_encoded_data;
+
+  EXPECT_EQ(encoded_data, expected);
+}
+
+TEST(ResponseIndeterminateLengthEncoder, NoInformationalResponses) {
+  std::string expected;
+  ASSERT_TRUE(
+      absl::HexStringToBytes(absl::StrCat("03", kEncodedResponse), &expected));
+
+  BinaryHttpResponse::IndeterminateLengthEncoder encoder;
+  ResponseIndeterminateLengthEncoderTestData test_data;
+  std::string encoded_data;
+
+  absl::StatusOr<std::string> status_or_encoded_data =
+      encoder.EncodeHeaders(200, absl::MakeSpan(test_data.headers));
+  QUICHE_EXPECT_OK(status_or_encoded_data);
+  encoded_data += *status_or_encoded_data;
+
+  status_or_encoded_data =
+      encoder.EncodeBodyChunks(absl::MakeSpan(test_data.body_chunks), true);
+  QUICHE_EXPECT_OK(status_or_encoded_data);
+  encoded_data += *status_or_encoded_data;
+
+  status_or_encoded_data =
+      encoder.EncodeTrailers(absl::MakeSpan(test_data.trailers));
+  QUICHE_EXPECT_OK(status_or_encoded_data);
+  encoded_data += *status_or_encoded_data;
+
+  EXPECT_EQ(encoded_data, expected);
+}
+
+TEST(ResponseIndeterminateLengthEncoder, EncodingChunksMultipleTimes) {
+  std::string expected;
+  ASSERT_TRUE(
+      absl::HexStringToBytes(absl::StrCat("03", kEncodedResponse), &expected));
+
+  BinaryHttpResponse::IndeterminateLengthEncoder encoder;
+  ResponseIndeterminateLengthEncoderTestData test_data;
+  std::string encoded_data;
+
+  absl::StatusOr<std::string> status_or_encoded_data =
+      encoder.EncodeHeaders(200, absl::MakeSpan(test_data.headers));
+  QUICHE_EXPECT_OK(status_or_encoded_data);
+  encoded_data += *status_or_encoded_data;
+
+  status_or_encoded_data = encoder.EncodeBodyChunks(
+      absl::MakeSpan(test_data.body_chunks.data(), 1), false);
+  QUICHE_EXPECT_OK(status_or_encoded_data);
+  encoded_data += *status_or_encoded_data;
+  status_or_encoded_data = encoder.EncodeBodyChunks(
+      absl::MakeSpan(test_data.body_chunks.data() + 1, 1), false);
+  QUICHE_EXPECT_OK(status_or_encoded_data);
+  encoded_data += *status_or_encoded_data;
+  status_or_encoded_data = encoder.EncodeBodyChunks(
+      absl::MakeSpan(test_data.body_chunks.data() + 2, 1), false);
+  QUICHE_EXPECT_OK(status_or_encoded_data);
+  encoded_data += *status_or_encoded_data;
+  status_or_encoded_data = encoder.EncodeBodyChunks(
+      absl::MakeSpan(test_data.body_chunks.data() + 3, 1), false);
+  QUICHE_EXPECT_OK(status_or_encoded_data);
+  encoded_data += *status_or_encoded_data;
+  status_or_encoded_data = encoder.EncodeBodyChunks({}, true);
+  QUICHE_EXPECT_OK(status_or_encoded_data);
+  encoded_data += *status_or_encoded_data;
+
+  status_or_encoded_data =
+      encoder.EncodeTrailers(absl::MakeSpan(test_data.trailers));
+  QUICHE_EXPECT_OK(status_or_encoded_data);
+  encoded_data += *status_or_encoded_data;
+  EXPECT_EQ(encoded_data, expected);
+}
+
+TEST(ResponseIndeterminateLengthEncoder, EncodingWrongStatusCodes) {
+  BinaryHttpResponse::IndeterminateLengthEncoder encoder;
+  absl::StatusOr<std::string> status_or_encoded_data =
+      encoder.EncodeInformationalResponse(99, {});
+  EXPECT_THAT(status_or_encoded_data,
+              test::StatusIs(absl::StatusCode::kInvalidArgument));
+
+  encoder = BinaryHttpResponse::IndeterminateLengthEncoder();
+  status_or_encoded_data = encoder.EncodeInformationalResponse(200, {});
+  EXPECT_THAT(status_or_encoded_data,
+              test::StatusIs(absl::StatusCode::kInvalidArgument));
+
+  encoder = BinaryHttpResponse::IndeterminateLengthEncoder();
+  status_or_encoded_data = encoder.EncodeHeaders(199, {});
+  EXPECT_THAT(status_or_encoded_data,
+              test::StatusIs(absl::StatusCode::kInvalidArgument));
+
+  encoder = BinaryHttpResponse::IndeterminateLengthEncoder();
+  status_or_encoded_data = encoder.EncodeHeaders(600, {});
+  EXPECT_THAT(status_or_encoded_data,
+              test::StatusIs(absl::StatusCode::kInvalidArgument));
+}
+
+TEST(ResponseIndeterminateLengthEncoder, OutOfOrderBodyChunks) {
+  BinaryHttpResponse::IndeterminateLengthEncoder encoder;
+  absl::StatusOr<std::string> status_or_encoded_data =
+      encoder.EncodeBodyChunks({}, true);
+  EXPECT_THAT(status_or_encoded_data,
+              test::StatusIs(absl::StatusCode::kInvalidArgument));
+}
+
+TEST(ResponseIndeterminateLengthEncoder, OutOfOrderTrailers) {
+  BinaryHttpResponse::IndeterminateLengthEncoder encoder;
+  absl::StatusOr<std::string> status_or_encoded_data =
+      encoder.EncodeTrailers({});
+  EXPECT_THAT(status_or_encoded_data,
+              test::StatusIs(absl::StatusCode::kInvalidArgument));
+}
+
+TEST(ResponseIndeterminateLengthEncoder, OutOfOrderInformationalResponse) {
+  // Cannot encode informational responses after headers.
+  BinaryHttpResponse::IndeterminateLengthEncoder encoder;
+  absl::StatusOr<std::string> status_or_encoded_data =
+      encoder.EncodeHeaders(200, {});
+  QUICHE_EXPECT_OK(status_or_encoded_data);
+  status_or_encoded_data = encoder.EncodeInformationalResponse(102, {});
+  EXPECT_THAT(status_or_encoded_data,
+              test::StatusIs(absl::StatusCode::kInvalidArgument));
+}
+
+TEST(ResponseIndeterminateLengthEncoder, MustNotEncodeChunksAfterChunksDone) {
+  BinaryHttpResponse::IndeterminateLengthEncoder encoder;
+  absl::StatusOr<std::string> status_or_encoded_data =
+      encoder.EncodeHeaders(200, {});
+  QUICHE_EXPECT_OK(status_or_encoded_data);
+  status_or_encoded_data = encoder.EncodeBodyChunks({}, true);
+  QUICHE_EXPECT_OK(status_or_encoded_data);
+  status_or_encoded_data = encoder.EncodeBodyChunks({}, true);
+  EXPECT_THAT(status_or_encoded_data,
+              test::StatusIs(absl::StatusCode::kInvalidArgument));
+}
+
+TEST(ResponseIndeterminateLengthEncoder, MustNotEncodeHeadersTwice) {
+  BinaryHttpResponse::IndeterminateLengthEncoder encoder;
+  absl::StatusOr<std::string> status_or_encoded_data =
+      encoder.EncodeHeaders(200, {});
+  QUICHE_EXPECT_OK(status_or_encoded_data);
+  status_or_encoded_data = encoder.EncodeHeaders(200, {});
+  EXPECT_THAT(status_or_encoded_data,
+              test::StatusIs(absl::StatusCode::kInvalidArgument));
+}
+
+TEST(ResponseIndeterminateLengthEncoder, MustNotEncodeTrailersTwice) {
+  BinaryHttpResponse::IndeterminateLengthEncoder encoder;
+  absl::StatusOr<std::string> status_or_encoded_data =
+      encoder.EncodeHeaders(200, {});
+  QUICHE_EXPECT_OK(status_or_encoded_data);
+  status_or_encoded_data = encoder.EncodeBodyChunks({}, true);
+  QUICHE_EXPECT_OK(status_or_encoded_data);
+  status_or_encoded_data = encoder.EncodeTrailers({});
+  QUICHE_EXPECT_OK(status_or_encoded_data);
+  status_or_encoded_data = encoder.EncodeTrailers({});
+  EXPECT_THAT(status_or_encoded_data,
+              test::StatusIs(absl::StatusCode::kInvalidArgument));
+}
+
 TEST(IndeterminateLengthDecoder, TruncatedTrailers) {
   RequestMessageSectionTestHandler handler;
   BinaryHttpRequest::IndeterminateLengthDecoder decoder(handler);