Landing Recent QUIC changes until 10:38 AM, Oct 17, 2016 UTC-4

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 85 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;
   }
 
-  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() << ").";
-    SendErrorResponse();
-    return;
-  }
-
   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() {
+  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() << ").";
+    SendErrorResponse();
+    return;
+  }
+
   if (!base::ContainsKey(request_headers_, ":authority") ||
       !base::ContainsKey(request_headers_, ":path")) {
     DVLOG(1) << "Request headers do not contain :authority or :path.";
     SendErrorResponse();
     return;
   }
 
   // Find response in cache. If not found, send error response.
   const QuicInMemoryCache::Response* response =
       QuicInMemoryCache::GetInstance()->GetResponse(
@@ skipping 78 matching lines @@
     SpdyHeaderBlock response_headers,
     StringPiece body) {
   SendHeadersAndBodyAndTrailers(std::move(response_headers), body,
                                 SpdyHeaderBlock());
 }
 
 void QuicSimpleServerStream::SendHeadersAndBodyAndTrailers(
     SpdyHeaderBlock response_headers,
     StringPiece body,
     SpdyHeaderBlock response_trailers) {
-  // This server only supports SPDY and HTTP, and neither handles bidirectional
-  // streaming.
-  if (!reading_stopped()) {
+  if (!allow_bidirectional_data() && !reading_stopped()) {
     StopReading();
   }
 
   // Send the headers, with a FIN if there's nothing else to send.
   bool send_fin = (body.empty() && response_trailers.empty());
   DVLOG(1) << "Writing headers (fin = " << send_fin
            << ") : " << response_headers.DebugString();
   WriteHeaders(std::move(response_headers), send_fin, nullptr);
   if (send_fin) {
     // Nothing else to send.
@@ skipping 16 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