Land Recent QUIC Changes.

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 <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
@@ skipping 140 matching lines @@
       : server_hostname_("example.com"),
         server_started_(false),
         strike_register_no_startup_period_(false) {
     net::IPAddressNumber ip;
     CHECK(net::ParseIPLiteralToNumber("127.0.0.1", &ip));
     server_address_ = IPEndPoint(ip, 0);
 
     client_supported_versions_ = GetParam().client_supported_versions;
     server_supported_versions_ = GetParam().server_supported_versions;
     negotiated_version_ = GetParam().negotiated_version;
-    FLAGS_limit_rto_increase_for_tests = true;
     FLAGS_enable_quic_pacing = GetParam().use_pacing;
     LOG(INFO) << "Using Configuration: " << GetParam();
 
     client_config_.SetDefaults();
     server_config_.SetDefaults();
     server_config_.set_initial_round_trip_time_us(kMaxInitialRoundTripTimeUs,
                                                   0);
 
     QuicInMemoryCachePeer::ResetForTests();
     AddToCache("GET", "https://www.google.com/foo",
@@ skipping 74 matching lines @@
                   StringPiece response_code,
                   StringPiece response_detail,
                   StringPiece body) {
     QuicInMemoryCache::GetInstance()->AddSimpleResponse(
         method, path, version, response_code, response_detail, body);
   }
 
   void SetPacketLossPercentage(int32 loss) {
     // TODO(rtenneti): enable when we can do random packet loss tests in
     // chrome's tree.
-    // client_writer_->set_fake_packet_loss_percentage(loss);
-    // server_writer_->set_fake_packet_loss_percentage(loss);
+    if (loss != 0 && loss != 100)
+      return;
+    client_writer_->set_fake_packet_loss_percentage(loss);
+    server_writer_->set_fake_packet_loss_percentage(loss);
   }
 
   void SetPacketSendDelay(QuicTime::Delta delay) {
     // TODO(rtenneti): enable when we can do random packet send delay tests in
     // chrome's tree.
     // client_writer_->set_fake_packet_delay(delay);
     // server_writer_->set_fake_packet_delay(delay);
   }
 
   void SetReorderPercentage(int32 reorder) {
@@ skipping 505 matching lines @@
   for (int i = 0; i < max_streams; ++i) {
     EXPECT_LT(0, client_->SendRequest("/large_response"));
   }
 
   // WaitForEvents waits 50ms and returns true if there are outstanding
   // requests.
   while (client_->client()->WaitForEvents() == true) {
   }
 }
 
+TEST_P(EndToEndTest, StreamCancelErrorTest) {
+  ASSERT_TRUE(Initialize());
+  string small_body;
+  GenerateBody(&small_body, 256);
+
+  AddToCache("GET", "/small_response", "HTTP/1.1", "200", "OK", small_body);
+
+  client_->client()->WaitForCryptoHandshakeConfirmed();
+
+  QuicSession* session = client_->client()->session();
+  // Lose the request.
+  SetPacketLossPercentage(100);
+  EXPECT_LT(0, client_->SendRequest("/small_response"));
+  client_->client()->WaitForEvents();
+  // Transmit the cancel, and ensure the connection is torn down properly.
+  SetPacketLossPercentage(0);
+  QuicStreamId stream_id = negotiated_version_ > QUIC_VERSION_12 ? 5 : 3;
+  session->SendRstStream(stream_id, QUIC_STREAM_CANCELLED);
+
+  // WaitForEvents waits 50ms and returns true if there are outstanding
+  // requests.
+  while (client_->client()->WaitForEvents() == true) {
+  }
+  if (negotiated_version_ > QUIC_VERSION_12) {
+    // It should be completely fine to RST a stream before any data has bee
+    // received for that stream.
+    EXPECT_EQ(QUIC_NO_ERROR, client_->connection_error());
+  } else {
+    // Check that the connection is always properly closed
+    // from a stream being RST before headers are decompressed.
+    EXPECT_EQ(QUIC_STREAM_RST_BEFORE_HEADERS_DECOMPRESSED,
+              client_->connection_error());
+  }
+}
+
 class WrongAddressWriter : public QuicTestWriter {
  public:
   WrongAddressWriter() {
     IPAddressNumber ip;
     CHECK(net::ParseIPLiteralToNumber("127.0.0.2", &ip));
     self_address_ = IPEndPoint(ip, 0);
   }
 
   virtual WriteResult WritePacket(
       const char* buffer, size_t buf_len,
@@ skipping 27 matching lines @@
   client_->SendSynchronousRequest("/bar");
 
   EXPECT_EQ(QUIC_STREAM_CONNECTION_ERROR, client_->stream_error());
   EXPECT_EQ(QUIC_ERROR_MIGRATING_ADDRESS, client_->connection_error());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net