Quic streams honor RST_STREAM + NO_ERROR on the write side.

net/tools/quic/end_to_end_test.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 <stddef.h>
 #include <string>
 #include <sys/epoll.h>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 1035 matching lines @@
   // Force the client to write with a stream ID belonging to a nonexistent
   // server-side stream.
   QuicSessionPeer::SetNextOutgoingStreamId(client_->client()->session(), 2);
 
   client_->SendCustomSynchronousRequest(request);
   // EXPECT_EQ(QUIC_STREAM_CONNECTION_ERROR, client_->stream_error());
   EXPECT_EQ(QUIC_STREAM_CONNECTION_ERROR, client_->stream_error());
   EXPECT_EQ(QUIC_INVALID_STREAM_ID, client_->connection_error());
 }
 
+TEST_P(EndToEndTest, EarlyResponseWithQuicStreamNoError) {
+  ASSERT_TRUE(Initialize());
+  client_->client()->WaitForCryptoHandshakeConfirmed();
+
+  string large_body;
+  GenerateBody(&large_body, 1024 * 1024);
+
+  HTTPMessage request(HttpConstants::HTTP_1_1, HttpConstants::POST, "/foo");
+  request.AddBody(large_body, false);
+
+  // Insert an invalid content_length field in request to trigger an early
+  // response from server.
+  request.AddHeader("content-length", "-3");
+
+  request.set_skip_message_validation(true);
+  client_->SendCustomSynchronousRequest(request);
+  EXPECT_EQ("bad", client_->response_body());
+  EXPECT_EQ(500u, client_->response_headers()->parsed_response_code());
+  EXPECT_EQ(QUIC_STREAM_NO_ERROR, client_->stream_error());
+  EXPECT_EQ(QUIC_NO_ERROR, client_->connection_error());
+}
+
 // TODO(rch): this test seems to cause net_unittests timeouts :|
 TEST_P(EndToEndTest, DISABLED_MultipleTermination) {
   ASSERT_TRUE(Initialize());
 
   HTTPMessage request(HttpConstants::HTTP_1_1, HttpConstants::POST, "/foo");
   request.AddHeader("content-length", "3");
   request.set_has_complete_message(false);
 
   // Set the offset so we won't frame.  Otherwise when we pick up termination
   // before HTTP framing is complete, we send an error and close the stream,
@@ skipping 993 matching lines @@
   request.set_skip_message_validation(true);
   request.set_has_complete_message(false);
 
   // Tell the client to not close the stream if it receives an early response.
   client_->set_allow_bidirectional_data(true);
   // Send the headers.
   client_->SendMessage(request);
   // Receive the response and let the server close writing.
   client_->WaitForInitialResponse();
   EXPECT_EQ(500u, client_->response_headers()->parsed_response_code());
-  // Send a body larger than the stream flow control window.
-  string body;
-  GenerateBody(&body, kBodySize);
-  client_->SendData(body, true);
 
-  if (FLAGS_quic_implement_stop_reading) {
-    // Run the client to let any buffered data be sent.
-    // (This is OK despite already waiting for a response.)
-    client_->WaitForResponse();
-    // There should be no buffered data to write in the client's stream.
+  if (negotiated_version_ <= QUIC_VERSION_28) {
+    // Send a body larger than the stream flow control window.
+    string body;
+    GenerateBody(&body, kBodySize);
+    client_->SendData(body, true);
+
+    if (FLAGS_quic_implement_stop_reading) {
+      // Run the client to let any buffered data be sent.
+      // (This is OK despite already waiting for a response.)
+      client_->WaitForResponse();
+      // There should be no buffered data to write in the client's stream.
+      ReliableQuicStream* stream = client_->client()->session()->GetStream(5);
+      EXPECT_FALSE(stream != nullptr && stream->HasBufferedData());
+    } else {
+      // Run the client for 0.1 second to let any buffered data be sent.
+      // Must have a timeout, as the stream will not close and cause a return.
+      // (This is OK despite already waiting for a response.)
+      client_->WaitForResponseForMs(100);
+      // There will be buffered data to write in the client's stream.
+      ReliableQuicStream* stream = client_->client()->session()->GetStream(5);
+      EXPECT_TRUE(stream != nullptr && stream->HasBufferedData());
+    }
+  } else {
+    client_->WaitForResponseForMs(100);
     ReliableQuicStream* stream = client_->client()->session()->GetStream(5);
-    EXPECT_FALSE(stream != nullptr && stream->HasBufferedData());
-  } else {
-    // Run the client for 0.1 second to let any buffered data be sent.
-    // Must have a timeout, as the stream will not close and cause a return.
-    // (This is OK despite already waiting for a response.)
-    client_->WaitForResponseForMs(static_cast<int64>(100));
-    // There will be buffered data to write in the client's stream.
-    ReliableQuicStream* stream = client_->client()->session()->GetStream(5);
-    EXPECT_TRUE(stream != nullptr && stream->HasBufferedData());
+    EXPECT_TRUE(stream == nullptr);
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net