Collapse InformationalResponseInternal class into public InformationalResponse.

PiperOrigin-RevId: 473325494

quiche/binary_http/binary_http_message.cc

diff --git a/quiche/binary_http/binary_http_message.cc b/quiche/binary_http/binary_http_message.cc
index 360c56d..1a6a149 100644
--- a/quiche/binary_http/binary_http_message.cc
+++ b/quiche/binary_http/binary_http_message.cc
@@ -228,7 +228,7 @@
   if (status_code > 199) {
     return absl::InvalidArgumentError("status code > 199");
   }
-  InformationalResponseInternal data(status_code);
+  InformationalResponse data(status_code);
   for (Field& header : header_fields) {
     data.AddField(header.name, std::move(header.value));
   }
@@ -241,16 +241,6 @@
   return EncodeAsKnownLength();
 }
 
-std::vector<BinaryHttpResponse::InformationalResponse>
-BinaryHttpResponse::GetInformationalResponse() const {
-  std::vector<InformationalResponse> data;
-  data.reserve(informational_response_control_data_.size());
-  for (const auto& control_data : informational_response_control_data_) {
-    data.push_back({control_data.response_code(), control_data.fields()});
-  }
-  return data;
-}
-
 absl::StatusOr<std::string> BinaryHttpResponse::EncodeAsKnownLength() const {
   std::string data;
   data.resize(EncodedSize());
@@ -285,21 +275,20 @@
          EncodedKnownLengthFieldsAndBodySize();
 }
 
-void BinaryHttpResponse::InformationalResponseInternal::AddField(
-    absl::string_view name, std::string value) {
+void BinaryHttpResponse::InformationalResponse::AddField(absl::string_view name,
+                                                         std::string value) {
   fields_.AddField({absl::AsciiStrToLower(name), std::move(value)});
 }
 
 // Appends the encoded fields and body to data.
-absl::Status BinaryHttpResponse::InformationalResponseInternal::Encode(
+absl::Status BinaryHttpResponse::InformationalResponse::Encode(
     quiche::QuicheDataWriter& writer) const {
-  writer.WriteVarInt62(response_code_);
+  writer.WriteVarInt62(status_code_);
   return fields_.Encode(writer);
 }
 
-uint64_t BinaryHttpResponse::InformationalResponseInternal::EncodedSize()
-    const {
-  return quiche::QuicheDataWriter::GetVarInt62Len(response_code_) +
+uint64_t BinaryHttpResponse::InformationalResponse::EncodedSize() const {
+  return quiche::QuicheDataWriter::GetVarInt62Len(status_code_) +
          fields_.EncodedSize();
 }
 

quiche/binary_http/binary_http_message.h

diff --git a/quiche/binary_http/binary_http_message.h b/quiche/binary_http/binary_http_message.h
index 843b860..e49b6a9 100644
--- a/quiche/binary_http/binary_http_message.h
+++ b/quiche/binary_http/binary_http_message.h
@@ -60,6 +60,10 @@
       return fields_;
     }
 
+    bool operator==(const BinaryHttpMessage::Fields& rhs) const {
+      return fields_ == rhs.fields_;
+    }
+
     // Encode fields in insertion order.
     // https://www.ietf.org/archive/id/draft-ietf-httpbis-binary-message-06.html#name-header-and-trailer-field-li
     absl::Status Encode(quiche::QuicheDataWriter& writer) const;
@@ -129,14 +133,47 @@
 class QUICHE_EXPORT_PRIVATE BinaryHttpResponse : public BinaryHttpMessage {
  public:
   // https://www.ietf.org/archive/id/draft-ietf-httpbis-binary-message-06.html#name-response-control-data
-  struct InformationalResponse {
-    uint16_t status_code;
-    const std::vector<Field>& header_fields;
+  // A response can contain 0 to N informational responses.  Each informational
+  // response contains a status code followed by a header field. Valid status
+  // codes are [100,199].
+  class InformationalResponse {
+   public:
+    explicit InformationalResponse(uint16_t status_code)
+        : status_code_(status_code) {}
+    InformationalResponse(uint16_t status_code,
+                          const std::vector<BinaryHttpMessage::Field>& fields)
+        : status_code_(status_code) {
+      for (const BinaryHttpMessage::Field& field : fields) {
+        AddField(field.name, field.value);
+      }
+    }
+
     bool operator==(
         const BinaryHttpResponse::InformationalResponse& rhs) const {
-      return status_code == rhs.status_code &&
-             header_fields == rhs.header_fields;
+      return status_code_ == rhs.status_code_ && fields_ == rhs.fields_;
     }
+
+    // Adds a field with the provided name, converted to lower case.
+    // Fields are in the order they are added.
+    void AddField(absl::string_view name, std::string value);
+
+    const std::vector<BinaryHttpMessage::Field>& fields() const {
+      return fields_.fields();
+    }
+
+    uint16_t status_code() const { return status_code_; }
+
+   private:
+    // Give BinaryHttpResponse access to Encoding functionality.
+    friend class BinaryHttpResponse;
+
+    uint64_t EncodedSize() const;
+
+    // Appends the encoded fields and body to `writer`.
+    absl::Status Encode(quiche::QuicheDataWriter& writer) const;
+
+    const uint16_t status_code_;
+    BinaryHttpMessage::Fields fields_;
   };
 
   explicit BinaryHttpResponse(uint16_t status_code)
@@ -152,45 +189,20 @@
                                         std::vector<Field> header_fields);
 
   uint16_t status_code() const { return status_code_; }
+
   // References in the returned `ResponseControlData` are invalidated on
   // `BinaryHttpResponse` object mutations.
-  std::vector<InformationalResponse> GetInformationalResponse() const;
+  const std::vector<InformationalResponse>& informational_responses() const {
+    return informational_response_control_data_;
+  }
 
  private:
-  //
-  // Valid response codes are [100,199].
-  // TODO(bschneider): Collapse this inner class into the public
-  // `InformationalResponse` struct.
-  class InformationalResponseInternal {
-   public:
-    explicit InformationalResponseInternal(uint16_t response_code)
-        : response_code_(response_code) {}
-
-    void AddField(absl::string_view name, std::string value);
-
-    // Appends the encoded fields and body to `writer`.
-    absl::Status Encode(quiche::QuicheDataWriter& writer) const;
-
-    uint64_t EncodedSize() const;
-
-    uint16_t response_code() const { return response_code_; }
-
-    const std::vector<BinaryHttpMessage::Field>& fields() const {
-      return fields_.fields();
-    }
-
-   private:
-    const uint16_t response_code_;
-    BinaryHttpMessage::Fields fields_;
-  };
-
   // Returns Binary Http known length request formatted response.
   absl::StatusOr<std::string> EncodeAsKnownLength() const;
 
   uint64_t EncodedSize() const;
 
-  std::vector<InformationalResponseInternal>
-      informational_response_control_data_;
+  std::vector<InformationalResponse> informational_response_control_data_;
   const uint16_t status_code_;
 };
 }  // namespace quiche

quiche/binary_http/binary_http_message_test.cc

diff --git a/quiche/binary_http/binary_http_message_test.cc b/quiche/binary_http/binary_http_message_test.cc
index 581848e..7d22bf3 100644
--- a/quiche/binary_http/binary_http_message_test.cc
+++ b/quiche/binary_http/binary_http_message_test.cc
@@ -264,7 +264,7 @@
       {"server", "Apache"}};
   ASSERT_THAT(response.GetHeaderFields(), ContainerEq(expected_fields));
   ASSERT_EQ(response.body(), "");
-  ASSERT_TRUE(response.GetInformationalResponse().empty());
+  ASSERT_TRUE(response.informational_responses().empty());
 }
 
 TEST(BinaryHttpResponse, EncodeBody) {
@@ -318,7 +318,7 @@
       {"server", "Apache"}};
   ASSERT_THAT(response.GetHeaderFields(), ContainerEq(expected_fields));
   ASSERT_EQ(response.body(), "Hello, world!\r\n");
-  ASSERT_TRUE(response.GetInformationalResponse().empty());
+  ASSERT_TRUE(response.informational_responses().empty());
 }
 
 TEST(BHttpResponse, AddBadInformationalResponseCode) {
@@ -482,7 +482,7 @@
       {"link", "</script.js>; rel=preload; as=script"}};
   std::vector<BinaryHttpResponse::InformationalResponse> expected_control = {
       {102, header102}, {103, header103}};
-  ASSERT_THAT(response.GetInformationalResponse(),
+  ASSERT_THAT(response.informational_responses(),
               ContainerEq(expected_control));
 }