Add QuicTestClient::partial_response_body(). To make implementation easier, change QuicSpdyClientStream::body() return type and make it const. Also change QuicSpdyClientBase::ResponseListener::OnCompleteResponse() signature accordingly, and make a copy explicit in PerStreamState construction. PiperOrigin-RevId: 500191114

diff --git a/quiche/quic/core/http/end_to_end_test.cc b/quiche/quic/core/http/end_to_end_test.cc
index 80161dd..83dc8a2 100644
--- a/quiche/quic/core/http/end_to_end_test.cc
+++ b/quiche/quic/core/http/end_to_end_test.cc

@@ -3871,7 +3871,7 @@
  public:
   void OnCompleteResponse(QuicStreamId id,
                           const Http2HeaderBlock& response_headers,
-                          const std::string& response_body) override {
+                          absl::string_view response_body) override {
     QUIC_DVLOG(1) << "response for stream " << id << " "
                   << response_headers.DebugString() << "\n"
                   << response_body;

diff --git a/quiche/quic/core/http/quic_spdy_client_stream.h b/quiche/quic/core/http/quic_spdy_client_stream.h
index 7a4f90a..9a952aa 100644
--- a/quiche/quic/core/http/quic_spdy_client_stream.h
+++ b/quiche/quic/core/http/quic_spdy_client_stream.h

@@ -51,7 +51,7 @@
                      bool fin);
 
   // Returns the response data.
-  const std::string& data() { return data_; }
+  absl::string_view data() const { return data_; }
 
   // Returns whatever headers have been received for this stream.
   const spdy::Http2HeaderBlock& response_headers() { return response_headers_; }

diff --git a/quiche/quic/test_tools/quic_test_client.cc b/quiche/quic/test_tools/quic_test_client.cc
index ecf67c4..224046a 100644
--- a/quiche/quic/test_tools/quic_test_client.cc
+++ b/quiche/quic/test_tools/quic_test_client.cc

@@ -708,6 +708,11 @@
   return bytes_written_;
 }
 
+absl::string_view QuicTestClient::partial_response_body() const {
+  return latest_created_stream_ == nullptr ? ""
+                                           : latest_created_stream_->data();
+}
+
 void QuicTestClient::OnClose(QuicSpdyStream* stream) {
   if (stream == nullptr) {
     return;
@@ -733,7 +738,7 @@
           client_stream->headers_decompressed(),
           client_stream->response_headers(),
           client_stream->preliminary_headers(),
-          (buffer_body() ? client_stream->data() : ""),
+          (buffer_body() ? std::string(client_stream->data()) : ""),
           client_stream->received_trailers(),
           // Use NumBytesConsumed to avoid counting retransmitted stream frames.
           client_stream->total_body_bytes_read() +

diff --git a/quiche/quic/test_tools/quic_test_client.h b/quiche/quic/test_tools/quic_test_client.h
index 4756e99..9abab23 100644
--- a/quiche/quic/test_tools/quic_test_client.h
+++ b/quiche/quic/test_tools/quic_test_client.h

@@ -166,16 +166,14 @@
   bool buffer_body() const;
   void set_buffer_body(bool buffer_body);
 
-  // Getters for stream state. Please note, these getters are divided into two
-  // groups. 1) returns state which only get updated once a complete response
-  // is received. 2) returns state of the oldest active stream which have
-  // received partial response (if any).
-  // Group 1.
+  // Getters for stream state that only get updated once a complete response is
+  // received.
   const spdy::Http2HeaderBlock& response_trailers() const;
   bool response_complete() const;
   int64_t response_body_size() const;
   const std::string& response_body() const;
-  // Group 2.
+  // Getters for stream state that return state of the oldest active stream that
+  // have received a partial response.
   bool response_headers_complete() const;
   const spdy::Http2HeaderBlock* response_headers() const;
   const spdy::Http2HeaderBlock* preliminary_headers() const;
@@ -183,6 +181,11 @@
   size_t bytes_read() const;
   size_t bytes_written() const;
 
+  // Returns response body received so far by the stream that has been most
+  // recently opened among currently open streams.  To query response body
+  // received by a stream that is already closed, use `response_body()` instead.
+  absl::string_view partial_response_body() const;
+
   // Returns once at least one complete response or a connection close has been
   // received from the server. If responses are received for multiple (say 2)
   // streams, next WaitForResponse will return immediately.

diff --git a/quiche/quic/tools/quic_spdy_client_base.cc b/quiche/quic/tools/quic_spdy_client_base.cc
index a34472c..b46e780 100644
--- a/quiche/quic/tools/quic_spdy_client_base.cc
+++ b/quiche/quic/tools/quic_spdy_client_base.cc

@@ -89,7 +89,7 @@
     preliminary_response_headers_ =
         client_stream->preliminary_headers().DebugString();
     latest_response_header_block_ = response_headers.Clone();
-    latest_response_body_ = client_stream->data();
+    latest_response_body_ = std::string(client_stream->data());
     latest_response_trailers_ =
         client_stream->received_trailers().DebugString();
   }

diff --git a/quiche/quic/tools/quic_spdy_client_base.h b/quiche/quic/tools/quic_spdy_client_base.h
index ba62c80..28c3e96 100644
--- a/quiche/quic/tools/quic_spdy_client_base.h
+++ b/quiche/quic/tools/quic_spdy_client_base.h

@@ -37,7 +37,7 @@
     virtual ~ResponseListener() {}
     virtual void OnCompleteResponse(
         QuicStreamId id, const spdy::Http2HeaderBlock& response_headers,
-        const std::string& response_body) = 0;
+        absl::string_view response_body) = 0;
   };
 
   // A piece of data that can be sent multiple times. For example, it can be a