Test refactors to allow for delaying response trailers.

net/tools/quic/quic_simple_server_stream.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/tools/quic/quic_simple_server_stream.h"
 
 #include <list>
 #include <utility>
 
 #include "base/logging.h"
@@ skipping 10 matching lines @@
 #include "net/tools/quic/quic_simple_server_session.h"
 
 using base::StringPiece;
 using base::StringToInt;
 using std::string;
 
 namespace net {
 
 QuicSimpleServerStream::QuicSimpleServerStream(QuicStreamId id,
                                                QuicSpdySession* session)
-    : QuicSpdyStream(id, session),
-      content_length_(-1),
-      response_started_(false) {}
+    : QuicSpdyStream(id, session), content_length_(-1) {}
 
 QuicSimpleServerStream::~QuicSimpleServerStream() {}
 
 void QuicSimpleServerStream::OnInitialHeadersComplete(bool fin,
                                                       size_t frame_len) {
   QuicSpdyStream::OnInitialHeadersComplete(fin, frame_len);
   if (!SpdyUtils::ParseHeaders(decompressed_headers().data(),
                                decompressed_headers().length(),
                                &content_length_, &request_headers_)) {
     DVLOG(1) << "Invalid headers";
@@ skipping 54 matching lines @@
   }
 
   // If the sequencer is closed, then all the body, including the fin, has been
   // consumed.
   OnFinRead();
 
   if (write_side_closed() || fin_buffered()) {
     return;
   }
 
-  // Subclass could have manually invoked SendResponse earlier.
-  if (!response_started_) {
-    SendResponse();
-  }
+  SendResponse();
 }
 
 void QuicSimpleServerStream::PushResponse(
     SpdyHeaderBlock push_request_headers) {
   if (id() % 2 != 0) {
     QUIC_BUG << "Client initiated stream shouldn't be used as promised stream.";
     return;
   }
   // Change the stream state to emulate a client request.
   request_headers_ = std::move(push_request_headers);
   content_length_ = 0;
   DVLOG(1) << "Stream " << id() << ": Ready to receive server push response.";
 
   // Set as if stream decompresed the headers and received fin.
   QuicSpdyStream::OnInitialHeadersComplete(/*fin=*/true, 0);
 }
 
 void QuicSimpleServerStream::SendResponse() {
-  DCHECK(!response_started_);
-  response_started_ = true;
-
   if (request_headers_.empty()) {
     DVLOG(1) << "Request headers empty.";
     SendErrorResponse();
     return;
   }
 
   if (content_length_ > 0 &&
       static_cast<uint64_t>(content_length_) != body_.size()) {
     DVLOG(1) << "Content length (" << content_length_ << ") != body size ("
              << body_.size() << ").";
@@ skipping 129 matching lines @@
   DVLOG(1) << "Writing trailers (fin = true): "
            << response_trailers.DebugString();
   WriteTrailers(std::move(response_trailers), nullptr);
 }
 
 const char* const QuicSimpleServerStream::kErrorResponseBody = "bad";
 const char* const QuicSimpleServerStream::kNotFoundResponseBody =
     "file not found";
 
 }  // namespace net